schain Commit - r186:d9fa53b18840 · 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,dataOut=None,
+                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:
+                    if dataOut != None:
-                        dataOut = self.createObjByDefault()
+                        self.dataOut = dataOut
-                    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, path, blocksPerFile, profilesPerBlock=None, set=0, ext=None):
+                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.dataOut = dataOut
+                        self.setup(dataOut, **kwargs)
-                        self.setup(**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, 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()
                 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, dataOut=None):
+                def __init__(self):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                     Return: None
                     """
-                    if dataOut == None:
-                        dataOut = Voltage()
-                    if not( isinstance(dataOut, Voltage) ):
-                        raise ValueError, "in VoltageReader, dataOut must be an Spectra class object"
-                    self.dataOut = dataOut
                     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, dataOut=None):
+                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()
                 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, 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
                     """
-                    if dataOut == None:
-                        dataOut = Spectra()
-                    if not( isinstance(dataOut, Spectra) ):
-                        raise ValueError, "in SpectraReader, dataOut must be an Spectra class object"
-                    self.dataOut = dataOut
                     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,~~dataOut~~=~~None~~,

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

dataOut = ~~self~~.~~createObjByDefault~~()

440

self.dataOut = dataOut

441

442

self.dataOut = dataOut

443

441

444

if online:

442

if online:

445

print "Searching files in online mode..."

443

print "Searching files in online mode..."

446

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)

447

445

448

if not(doypath):

446

if not(doypath):

449

for nTries in range( self.nTries ):

447

for nTries in range( self.nTries ):

450

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)

451

time.sleep( self.delay )

449

time.sleep( self.delay )

452

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)

453

if doypath:

451

if doypath:

454

break

452

break

455

453

456

if not(doypath):

454

if not(doypath):

457

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

455

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

458

return None

456

return None

459

457

460

self.year = year

458

self.year = year

461

self.doy = doy

459

self.doy = doy

462

self.set = set - 1

460

self.set = set - 1

463

self.path = path

461

self.path = path

464

462

465

else:

463

else:

466

print "Searching files in offline mode ..."

464

print "Searching files in offline mode ..."

467

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)

468

466

469

if not(pathList):

467

if not(pathList):

470

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,

471

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

469

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

472

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

470

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

473

471

474

sys.exit(-1)

472

sys.exit(-1)

475

473

476

474

477

self.fileIndex = -1

475

self.fileIndex = -1

478

self.pathList = pathList

476

self.pathList = pathList

479

self.filenameList = filenameList

477

self.filenameList = filenameList

480

478

481

self.online = online

479

self.online = online

482

self.delay = delay

480

self.delay = delay

483

ext = ext.lower()

481

ext = ext.lower()

484

self.ext = ext

482

self.ext = ext

485

483

486

if not(self.setNextFile()):

484

if not(self.setNextFile()):

487

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

485

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

488

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

489

elif startDate != None:

487

elif startDate != None:

490

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

491

else:

489

else:

492

print "No files"

490

print "No files"

493

491

494

sys.exit(-1)

492

sys.exit(-1)

495

493

496

# self.updateDataHeader()

494

# self.updateDataHeader()

497

495

498

return self.dataOut

496

return self.dataOut

499

497

500

def __setNextFileOffline(self):

498

def __setNextFileOffline(self):

501

499

502

idFile = self.fileIndex

500

idFile = self.fileIndex

503

501

504

while (True):

502

while (True):

505

idFile += 1

503

idFile += 1

506

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

504

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

507

self.flagNoMoreFiles = 1

505

self.flagNoMoreFiles = 1

508

print "No more Files"

506

print "No more Files"

509

return 0

507

return 0

510

508

511

filename = self.filenameList[idFile]

509

filename = self.filenameList[idFile]

512

510

513

if not(self.__verifyFile(filename)):

511

if not(self.__verifyFile(filename)):

514

continue

512

continue

515

513

516

fileSize = os.path.getsize(filename)

514

fileSize = os.path.getsize(filename)

517

fp = open(filename,'rb')

515

fp = open(filename,'rb')

518

break

516

break

519

517

520

self.flagIsNewFile = 1

518

self.flagIsNewFile = 1

521

self.fileIndex = idFile

519

self.fileIndex = idFile

522

self.filename = filename

520

self.filename = filename

523

self.fileSize = fileSize

521

self.fileSize = fileSize

524

self.fp = fp

522

self.fp = fp

525

523

526

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

524

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

527

525

528

return 1

526

return 1

529

527

530

def __setNextFileOnline(self):

528

def __setNextFileOnline(self):

531

"""

529

"""

532

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

533

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

534

siguientes.

532

siguientes.

535

533

536

Affected:

534

Affected:

537

self.flagIsNewFile

535

self.flagIsNewFile

538

self.filename

536

self.filename

539

self.fileSize

537

self.fileSize

540

self.fp

538

self.fp

541

self.set

539

self.set

542

self.flagNoMoreFiles

540

self.flagNoMoreFiles

543

541

544

Return:

542

Return:

545

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

546

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

547

545

548

Excepciones:

546

Excepciones:

549

Si un determinado file no puede ser abierto

547

Si un determinado file no puede ser abierto

550

"""

548

"""

551

nFiles = 0

549

nFiles = 0

552

fileOk_flag = False

550

fileOk_flag = False

553

firstTime_flag = True

551

firstTime_flag = True

554

552

555

self.set += 1

553

self.set += 1

556

554

557

#busca el 1er file disponible

555

#busca el 1er file disponible

558

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 )

559

if file:

557

if file:

560

if self.__verifyFile(file, False):

558

if self.__verifyFile(file, False):

561

fileOk_flag = True

559

fileOk_flag = True

562

560

563

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

561

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

564

if not(fileOk_flag):

562

if not(fileOk_flag):

565

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

566

564

567

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

568

tries = self.nTries

566

tries = self.nTries

569

else:

567

else:

570

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

571

569

572

for nTries in range( tries ):

570

for nTries in range( tries ):

573

if firstTime_flag:

571

if firstTime_flag:

574

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 )

575

time.sleep( self.delay )

573

time.sleep( self.delay )

576

else:

574

else:

577

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)

578

576

579

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 )

580

if file:

578

if file:

581

if self.__verifyFile(file):

579

if self.__verifyFile(file):

582

fileOk_flag = True

580

fileOk_flag = True

583

break

581

break

584

582

585

if fileOk_flag:

583

if fileOk_flag:

586

break

584

break

587

585

588

firstTime_flag = False

586

firstTime_flag = False

589

587

590

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

591

self.set += 1

589

self.set += 1

592

590

593

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

594

self.set = 0

592

self.set = 0

595

self.doy += 1

593

self.doy += 1

596

594

597

if fileOk_flag:

595

if fileOk_flag:

598

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

596

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

599

self.filename = file

597

self.filename = file

600

self.flagIsNewFile = 1

598

self.flagIsNewFile = 1

601

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

599

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

602

self.fp = open(file)

600

self.fp = open(file)

603

self.flagNoMoreFiles = 0

601

self.flagNoMoreFiles = 0

604

print 'Setting the file: %s' % file

602

print 'Setting the file: %s' % file

605

else:

603

else:

606

self.fileSize = 0

604

self.fileSize = 0

607

self.filename = None

605

self.filename = None

608

self.flagIsNewFile = 0

606

self.flagIsNewFile = 0

609

self.fp = None

607

self.fp = None

610

self.flagNoMoreFiles = 1

608

self.flagNoMoreFiles = 1

611

print 'No more Files'

609

print 'No more Files'

612

610

613

return fileOk_flag

611

return fileOk_flag

614

612

615

613

616

def setNextFile(self):

614

def setNextFile(self):

617

if self.fp != None:

615

if self.fp != None:

618

self.fp.close()

616

self.fp.close()

619

617

620

if self.online:

618

if self.online:

621

newFile = self.__setNextFileOnline()

619

newFile = self.__setNextFileOnline()

622

else:

620

else:

623

newFile = self.__setNextFileOffline()

621

newFile = self.__setNextFileOffline()

624

622

625

if not(newFile):

623

if not(newFile):

626

return 0

624

return 0

627

625

628

self.__readFirstHeader()

626

self.__readFirstHeader()

629

self.nReadBlocks = 0

627

self.nReadBlocks = 0

630

return 1

628

return 1

631

629

632

def __setNewBlock(self):

630

def __setNewBlock(self):

633

if self.fp == None:

631

if self.fp == None:

634

return 0

632

return 0

635

633

636

if self.flagIsNewFile:

634

if self.flagIsNewFile:

637

return 1

635

return 1

638

636

639

self.lastUTTime = self.basicHeaderObj.utc

637

self.lastUTTime = self.basicHeaderObj.utc

640

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

638

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

641

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

639

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

642

640

643

if (currentSize >= neededSize):

641

if (currentSize >= neededSize):

644

self.__rdBasicHeader()

642

self.__rdBasicHeader()

645

return 1

643

return 1

646

644

647

if not(self.setNextFile()):

645

if not(self.setNextFile()):

648

return 0

646

return 0

649

647

650

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

648

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

651

649

652

self.flagTimeBlock = 0

650

self.flagTimeBlock = 0

653

651

654

if deltaTime > self.maxTimeStep:

652

if deltaTime > self.maxTimeStep:

655

self.flagTimeBlock = 1

653

self.flagTimeBlock = 1

656

654

657

return 1

655

return 1

658

656

659

657

660

def readNextBlock(self):

658

def readNextBlock(self):

661

if not(self.__setNewBlock()):

659

if not(self.__setNewBlock()):

662

return 0

660

return 0

663

661

664

if not(self.readBlock()):

662

if not(self.readBlock()):

665

return 0

663

return 0

666

664

667

return 1

665

return 1

668

666

669

def __rdProcessingHeader(self, fp=None):

667

def __rdProcessingHeader(self, fp=None):

670

if fp == None:

668

if fp == None:

671

fp = self.fp

669

fp = self.fp

672

670

673

self.processingHeaderObj.read(fp)

671

self.processingHeaderObj.read(fp)

674

672

675

def __rdRadarControllerHeader(self, fp=None):

673

def __rdRadarControllerHeader(self, fp=None):

676

if fp == None:

674

if fp == None:

677

fp = self.fp

675

fp = self.fp

678

676

679

self.radarControllerHeaderObj.read(fp)

677

self.radarControllerHeaderObj.read(fp)

680

678

681

def __rdSystemHeader(self, fp=None):

679

def __rdSystemHeader(self, fp=None):

682

if fp == None:

680

if fp == None:

683

fp = self.fp

681

fp = self.fp

684

682

685

self.systemHeaderObj.read(fp)

683

self.systemHeaderObj.read(fp)

686

684

687

def __rdBasicHeader(self, fp=None):

685

def __rdBasicHeader(self, fp=None):

688

if fp == None:

686

if fp == None:

689

fp = self.fp

687

fp = self.fp

690

688

691

self.basicHeaderObj.read(fp)

689

self.basicHeaderObj.read(fp)

692

690

693

691

694

def __readFirstHeader(self):

692

def __readFirstHeader(self):

695

self.__rdBasicHeader()

693

self.__rdBasicHeader()

696

self.__rdSystemHeader()

694

self.__rdSystemHeader()

697

self.__rdRadarControllerHeader()

695

self.__rdRadarControllerHeader()

698

self.__rdProcessingHeader()

696

self.__rdProcessingHeader()

699

697

700

self.firstHeaderSize = self.basicHeaderObj.size

698

self.firstHeaderSize = self.basicHeaderObj.size

701

699

702

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

703

if datatype == 0:

701

if datatype == 0:

704

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

702

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

705

elif datatype == 1:

703

elif datatype == 1:

706

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

704

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

707

elif datatype == 2:

705

elif datatype == 2:

708

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

706

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

709

elif datatype == 3:

707

elif datatype == 3:

710

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

708

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

711

elif datatype == 4:

709

elif datatype == 4:

712

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

710

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

713

elif datatype == 5:

711

elif datatype == 5:

714

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

712

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

715

else:

713

else:

716

raise ValueError, 'Data type was not defined'

714

raise ValueError, 'Data type was not defined'

717

715

718

self.dtype = datatype_str

716

self.dtype = datatype_str

719

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

717

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

720

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)

721

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

719

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

722

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

720

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

723

self.getBlockDimension()

721

self.getBlockDimension()

724

722

725

723

726

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

724

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

727

msg = None

725

msg = None

728

try:

726

try:

729

fp = open(filename, 'rb')

727

fp = open(filename, 'rb')

730

currentPosition = fp.tell()

728

currentPosition = fp.tell()

731

except:

729

except:

732

if msgFlag:

730

if msgFlag:

733

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

731

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

734

return False

732

return False

735

733

736

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

734

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

737

735

738

if neededSize == 0:

736

if neededSize == 0:

739

basicHeaderObj = BasicHeader()

737

basicHeaderObj = BasicHeader()

740

systemHeaderObj = SystemHeader()

738

systemHeaderObj = SystemHeader()

741

radarControllerHeaderObj = RadarControllerHeader()

739

radarControllerHeaderObj = RadarControllerHeader()

742

processingHeaderObj = ProcessingHeader()

740

processingHeaderObj = ProcessingHeader()

743

741

744

try:

742

try:

745

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

743

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

746

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

744

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

747

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

745

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

748

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

746

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

749

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

750

748

751

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

749

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

752

750

753

except:

751

except:

754

if msgFlag:

752

if msgFlag:

755

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

756

754

757

fp.close()

755

fp.close()

758

return False

756

return False

759

else:

757

else:

760

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

761

759

762

fp.close()

760

fp.close()

763

fileSize = os.path.getsize(filename)

761

fileSize = os.path.getsize(filename)

764

currentSize = fileSize - currentPosition

762

currentSize = fileSize - currentPosition

765

if currentSize < neededSize:

763

if currentSize < neededSize:

766

if msgFlag and (msg != None):

764

if msgFlag and (msg != None):

767

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

768

return False

766

return False

769

767

770

return True

768

return True

771

769

772

def getData():

770

def getData():

773

pass

771

pass

774

772

775

def hasNotDataInBuffer():

773

def hasNotDataInBuffer():

776

pass

774

pass

777

775

778

def readBlock():

776

def readBlock():

779

pass

777

pass

780

778

781

def run(self, **kwargs):

779

def run(self, **kwargs):

782

780

783

if not(self.isConfig):

781

if not(self.isConfig):

784

782

785

# self.dataOut = dataOut

783

# self.dataOut = dataOut

786

self.setup(**kwargs)

784

self.setup(**kwargs)

787

self.isConfig = True

785

self.isConfig = True

788

786

789

self.getData()

787

self.getData()

790

788

791

class JRODataWriter(JRODataIO):

789

class JRODataWriter(JRODataIO):

792

790

793

"""

791

"""

794

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

795

de los datos siempre se realiza por bloques.

793

de los datos siempre se realiza por bloques.

796

"""

794

"""

797

795

798

blockIndex = 0

796

blockIndex = 0

799

797

800

path = None

798

path = None

801

799

802

setFile = None

800

setFile = None

803

801

804

profilesPerBlock = None

802

profilesPerBlock = None

805

803

806

blocksPerFile = None

804

blocksPerFile = None

807

805

808

nWriteBlocks = 0

806

nWriteBlocks = 0

809

807

810

def __init__(self, dataOut=None):

808

def __init__(self, dataOut=None):

811

raise ValueError, "Not implemented"

809

raise ValueError, "Not implemented"

812

810

813

811

814

def hasAllDataInBuffer(self):

812

def hasAllDataInBuffer(self):

815

raise ValueError, "Not implemented"

813

raise ValueError, "Not implemented"

816

814

817

815

818

def setBlockDimension(self):

816

def setBlockDimension(self):

819

raise ValueError, "Not implemented"

817

raise ValueError, "Not implemented"

820

818

821

819

822

def writeBlock(self):

820

def writeBlock(self):

823

raise ValueError, "No implemented"

821

raise ValueError, "No implemented"

824

822

825

823

826

def putData(self):

824

def putData(self):

827

raise ValueError, "No implemented"

825

raise ValueError, "No implemented"

828

826

829

def getDataHeader(self):

827

def getDataHeader(self):

830

"""

828

"""

831

Obtiene una copia del First Header

829

Obtiene una copia del First Header

832

830

833

Affected:

831

Affected:

834

832

835

self.basicHeaderObj

833

self.basicHeaderObj

836

self.systemHeaderObj

834

self.systemHeaderObj

837

self.radarControllerHeaderObj

835

self.radarControllerHeaderObj

838

self.processingHeaderObj self.

836

self.processingHeaderObj self.

839

837

840

Return:

838

Return:

841

None

839

None

842

"""

840

"""

843

841

844

raise ValueError, "No implemented"

842

raise ValueError, "No implemented"

845

843

846

def getBasicHeader(self):

844

def getBasicHeader(self):

847

845

848

self.basicHeaderObj.size = self.basicHeaderSize #bytes

846

self.basicHeaderObj.size = self.basicHeaderSize #bytes

849

self.basicHeaderObj.version = self.versionFile

847

self.basicHeaderObj.version = self.versionFile

850

self.basicHeaderObj.dataBlock = self.nTotalBlocks

848

self.basicHeaderObj.dataBlock = self.nTotalBlocks

851

849

852

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

850

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

853

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

851

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

854

852

855

self.basicHeaderObj.utc = utc

853

self.basicHeaderObj.utc = utc

856

self.basicHeaderObj.miliSecond = milisecond

854

self.basicHeaderObj.miliSecond = milisecond

857

self.basicHeaderObj.timeZone = 0

855

self.basicHeaderObj.timeZone = 0

858

self.basicHeaderObj.dstFlag = 0

856

self.basicHeaderObj.dstFlag = 0

859

self.basicHeaderObj.errorCount = 0

857

self.basicHeaderObj.errorCount = 0

860

858

861

def __writeFirstHeader(self):

859

def __writeFirstHeader(self):

862

"""

860

"""

863

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)

864

862

865

Affected:

863

Affected:

866

__dataType

864

__dataType

867

865

868

Return:

866

Return:

869

None

867

None

870

"""

868

"""

871

869

872

# CALCULAR PARAMETROS

870

# CALCULAR PARAMETROS

873

871

874

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

872

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

875

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

873

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

876

874

877

self.basicHeaderObj.write(self.fp)

875

self.basicHeaderObj.write(self.fp)

878

self.systemHeaderObj.write(self.fp)

876

self.systemHeaderObj.write(self.fp)

879

self.radarControllerHeaderObj.write(self.fp)

877

self.radarControllerHeaderObj.write(self.fp)

880

self.processingHeaderObj.write(self.fp)

878

self.processingHeaderObj.write(self.fp)

881

879

882

self.dtype = self.dataOut.dtype

880

self.dtype = self.dataOut.dtype

883

881

884

def __setNewBlock(self):

882

def __setNewBlock(self):

885

"""

883

"""

886

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

887

885

888

Return:

886

Return:

889

0 : si no pudo escribir nada

887

0 : si no pudo escribir nada

890

1 : Si escribio el Basic el First Header

888

1 : Si escribio el Basic el First Header

891

"""

889

"""

892

if self.fp == None:

890

if self.fp == None:

893

self.setNextFile()

891

self.setNextFile()

894

892

895

if self.flagIsNewFile:

893

if self.flagIsNewFile:

896

return 1

894

return 1

897

895

898

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

896

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

899

self.basicHeaderObj.write(self.fp)

897

self.basicHeaderObj.write(self.fp)

900

return 1

898

return 1

901

899

902

if not( self.setNextFile() ):

900

if not( self.setNextFile() ):

903

return 0

901

return 0

904

902

905

return 1

903

return 1

906

904

907

905

908

def writeNextBlock(self):

906

def writeNextBlock(self):

909

"""

907

"""

910

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

911

909

912

Return:

910

Return:

913

0 : Si no hizo pudo escribir el bloque de datos

911

0 : Si no hizo pudo escribir el bloque de datos

914

1 : Si no pudo escribir el bloque de datos

912

1 : Si no pudo escribir el bloque de datos

915

"""

913

"""

916

if not( self.__setNewBlock() ):

914

if not( self.__setNewBlock() ):

917

return 0

915

return 0

918

916

919

self.writeBlock()

917

self.writeBlock()

920

918

921

return 1

919

return 1

922

920

923

def setNextFile(self):

921

def setNextFile(self):

924

"""

922

"""

925

Determina el siguiente file que sera escrito

923

Determina el siguiente file que sera escrito

926

924

927

Affected:

925

Affected:

928

self.filename

926

self.filename

929

self.subfolder

927

self.subfolder

930

self.fp

928

self.fp

931

self.setFile

929

self.setFile

932

self.flagIsNewFile

930

self.flagIsNewFile

933

931

934

Return:

932

Return:

935

0 : Si el archivo no puede ser escrito

933

0 : Si el archivo no puede ser escrito

936

1 : Si el archivo esta listo para ser escrito

934

1 : Si el archivo esta listo para ser escrito

937

"""

935

"""

938

ext = self.ext

936

ext = self.ext

939

path = self.path

937

path = self.path

940

938

941

if self.fp != None:

939

if self.fp != None:

942

self.fp.close()

940

self.fp.close()

943

941

944

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

942

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

945

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)

946

944

947

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

945

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

948

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

946

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

949

os.mkdir(doypath)

947

os.mkdir(doypath)

950

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

948

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

951

else:

949

else:

952

filesList = os.listdir( doypath )

950

filesList = os.listdir( doypath )

953

if len( filesList ) > 0:

951

if len( filesList ) > 0:

954

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

952

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

955

filen = filesList[-1]

953

filen = filesList[-1]

956

# el filename debera tener el siguiente formato

954

# el filename debera tener el siguiente formato

957

# 0 1234 567 89A BCDE (hex)

955

# 0 1234 567 89A BCDE (hex)

958

# x YYYY DDD SSS .ext

956

# x YYYY DDD SSS .ext

959

if isNumber( filen[8:11] ):

957

if isNumber( filen[8:11] ):

960

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

961

else:

959

else:

962

self.setFile = -1

960

self.setFile = -1

963

else:

961

else:

964

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

962

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

965

963

966

setFile = self.setFile

964

setFile = self.setFile

967

setFile += 1

965

setFile += 1

968

966

969

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

967

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

970

timeTuple.tm_year,

968

timeTuple.tm_year,

971

timeTuple.tm_yday,

969

timeTuple.tm_yday,

972

setFile,

970

setFile,

973

ext )

971

ext )

974

972

975

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

973

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

976

974

977

fp = open( filename,'wb' )

975

fp = open( filename,'wb' )

978

976

979

self.blockIndex = 0

977

self.blockIndex = 0

980

978

981

#guardando atributos

979

#guardando atributos

982

self.filename = filename

980

self.filename = filename

983

self.subfolder = subfolder

981

self.subfolder = subfolder

984

self.fp = fp

982

self.fp = fp

985

self.setFile = setFile

983

self.setFile = setFile

986

self.flagIsNewFile = 1

984

self.flagIsNewFile = 1

987

985

988

self.getDataHeader()

986

self.getDataHeader()

989

987

990

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

988

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

991

989

992

self.__writeFirstHeader()

990

self.__writeFirstHeader()

993

991

994

return 1

992

return 1

995

993

996

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

994

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

997

"""

995

"""

998

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

999

997

1000

Inputs:

998

Inputs:

1001

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

1002

format : formato en el cual sera salvado un file

1000

format : formato en el cual sera salvado un file

1003

set : el setebo del file

1001

set : el setebo del file

1004

1002

1005

Return:

1003

Return:

1006

0 : Si no realizo un buen seteo

1004

0 : Si no realizo un buen seteo

1007

1 : Si realizo un buen seteo

1005

1 : Si realizo un buen seteo

1008

"""

1006

"""

1009

1007

1010

if ext == None:

1008

if ext == None:

1011

ext = self.ext

1009

ext = self.ext

1012

1010

1013

ext = ext.lower()

1011

ext = ext.lower()

1014

1012

1015

self.ext = ext

1013

self.ext = ext

1016

1014

1017

self.path = path

1015

self.path = path

1018

1016

1019

self.setFile = set - 1

1017

self.setFile = set - 1

1020

1018

1021

self.blocksPerFile = blocksPerFile

1019

self.blocksPerFile = blocksPerFile

1022

1020

1023

self.profilesPerBlock = profilesPerBlock

1021

self.profilesPerBlock = profilesPerBlock

1024

1022

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.dataOut = ~~dataOut~~

1037

self.setup(dataOut, **kwargs)

1038

self.setup(**kwargs)

1039

self.isConfig = True

1038

self.isConfig = True

1040

1039

1041

self.putData()

1040

self.putData()

1042

1041

1043

class VoltageReader(JRODataReader):

1042

class VoltageReader(JRODataReader):

1044

"""

1043

"""

1045

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

1046

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:

1047

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

1046

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

1048

1047

1049

perfiles * alturas * canales

1048

perfiles * alturas * canales

1050

1049

1051

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

1050

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

1052

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

1053

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

1054

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

1055

1054

1056

Example:

1055

Example:

1057

1056

1058

dpath = "/home/myuser/data"

1057

dpath = "/home/myuser/data"

1059

1058

1060

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)

1061

1060

1062

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)

1063

1062

1064

readerObj = VoltageReader()

1063

readerObj = VoltageReader()

1065

1064

1066

readerObj.setup(dpath, startTime, endTime)

1065

readerObj.setup(dpath, startTime, endTime)

1067

1066

1068

while(True):

1067

while(True):

1069

1068

1070

#to get one profile

1069

#to get one profile

1071

profile = readerObj.getData()

1070

profile = readerObj.getData()

1072

1071

1073

#print the profile

1072

#print the profile

1074

print profile

1073

print profile

1075

1074

1076

#If you want to see all datablock

1075

#If you want to see all datablock

1077

print readerObj.datablock

1076

print readerObj.datablock

1078

1077

1079

if readerObj.flagNoMoreFiles:

1078

if readerObj.flagNoMoreFiles:

1080

break

1079

break

1081

1080

1082

"""

1081

"""

1083

1082

1084

ext = ".r"

1083

ext = ".r"

1085

1084

1086

optchar = "D"

1085

optchar = "D"

1087

dataOut = None

1086

dataOut = None

1088

1087

1089

1088

1090

def __init__(self, ~~dataOut~~=~~None~~):

1089

def __init__(self):

1091

"""

1090

"""

1092

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.

1093

1092

1094

Input:

1093

Input:

1095

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

1094

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

1096

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

1097

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

1096

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

1098

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

1099

bloque de datos.

1098

bloque de datos.

1100

Si este parametro no es pasado se creara uno internamente.

1099

Si este parametro no es pasado se creara uno internamente.

1101

1100

1102

Variables afectadas:

1101

Variables afectadas:

1103

self.dataOut

1102

self.dataOut

1104

1103

1105

Return:

1104

Return:

1106

None

1105

None

1107

"""

1106

"""

1108

1107

1109

self.isConfig = False

1108

self.isConfig = False

1110

1109

1111

self.datablock = None

1110

self.datablock = None

1112

1111

1113

self.utc = 0

1112

self.utc = 0

1114

1113

1115

self.ext = ".r"

1114

self.ext = ".r"

1116

1115

1117

self.optchar = "D"

1116

self.optchar = "D"

1118

1117

1119

self.basicHeaderObj = BasicHeader()

1118

self.basicHeaderObj = BasicHeader()

1120

1119

1121

self.systemHeaderObj = SystemHeader()

1120

self.systemHeaderObj = SystemHeader()

1122

1121

1123

self.radarControllerHeaderObj = RadarControllerHeader()

1122

self.radarControllerHeaderObj = RadarControllerHeader()

1124

1123

1125

self.processingHeaderObj = ProcessingHeader()

1124

self.processingHeaderObj = ProcessingHeader()

1126

1125

1127

self.online = 0

1126

self.online = 0

1128

1127

1129

self.fp = None

1128

self.fp = None

1130

1129

1131

self.idFile = None

1130

self.idFile = None

1132

1131

1133

self.dtype = None

1132

self.dtype = None

1134

1133

1135

self.fileSizeByHeader = None

1134

self.fileSizeByHeader = None

1136

1135

1137

self.filenameList = []

1136

self.filenameList = []

1138

1137

1139

self.filename = None

1138

self.filename = None

1140

1139

1141

self.fileSize = None

1140

self.fileSize = None

1142

1141

1143

self.firstHeaderSize = 0

1142

self.firstHeaderSize = 0

1144

1143

1145

self.basicHeaderSize = 24

1144

self.basicHeaderSize = 24

1146

1145

1147

self.pathList = []

1146

self.pathList = []

1148

1147

1149

self.filenameList = []

1148

self.filenameList = []

1150

1149

1151

self.lastUTTime = 0

1150

self.lastUTTime = 0

1152

1151

1153

self.maxTimeStep = 30

1152

self.maxTimeStep = 30

1154

1153

1155

self.flagNoMoreFiles = 0

1154

self.flagNoMoreFiles = 0

1156

1155

1157

self.set = 0

1156

self.set = 0

1158

1157

1159

self.path = None

1158

self.path = None

1160

1159

1161

self.profileIndex = 9999

1160

self.profileIndex = 9999

1162

1161

1163

self.delay = 3 #seconds

1162

self.delay = 3 #seconds

1164

1163

1165

self.nTries = 3 #quantity tries

1164

self.nTries = 3 #quantity tries

1166

1165

1167

self.nFiles = 3 #number of files for searching

1166

self.nFiles = 3 #number of files for searching

1168

1167

1169

self.nReadBlocks = 0

1168

self.nReadBlocks = 0

1170

1169

1171

self.flagIsNewFile = 1

1170

self.flagIsNewFile = 1

1172

1171

1173

self.ippSeconds = 0

1172

self.ippSeconds = 0

1174

1173

1175

self.flagTimeBlock = 0

1174

self.flagTimeBlock = 0

1176

1175

1177

self.flagIsNewBlock = 0

1176

self.flagIsNewBlock = 0

1178

1177

1179

self.nTotalBlocks = 0

1178

self.nTotalBlocks = 0

1180

1179

1181

self.blocksize = 0

1180

self.blocksize = 0

1181

1182

dataOut = self.createObjByDefault()

1182

1183

def createObjByDefault(self):

1184

def createObjByDefault(self):

1184

1185

dataObj = Voltage()

1186

dataObj = Voltage()

1186

1187

return dataObj

1188

return dataObj

1188

1189

def __hasNotDataInBuffer(self):

1190

def __hasNotDataInBuffer(self):

1190

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

1191

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

1191

return 1

1192

return 1

1192

return 0

1193

return 0

1193

1194

1195

def getBlockDimension(self):

1196

def getBlockDimension(self):

1196

"""

1197

"""

1197

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

1198

1199

Affected:

1200

Affected:

1200

self.blocksize

1201

self.blocksize

1201

1202

Return:

1203

Return:

1203

None

1204

None

1204

"""

1205

"""

1205

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

1206

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

1206

self.blocksize = pts2read

1207

self.blocksize = pts2read

1207

1208

1209

def readBlock(self):

1210

def readBlock(self):

1210

"""

1211

"""

1211

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

1212

(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

1213

(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

1214

es seteado a 0

1215

es seteado a 0

1215

1216

Inputs:

1217

Inputs:

1217

None

1218

None

1218

1219

Return:

1220

Return:

1220

None

1221

None

1221

1222

Affected:

1223

Affected:

1223

self.profileIndex

1224

self.profileIndex

1224

self.datablock

1225

self.datablock

1225

self.flagIsNewFile

1226

self.flagIsNewFile

1226

self.flagIsNewBlock

1227

self.flagIsNewBlock

1227

self.nTotalBlocks

1228

self.nTotalBlocks

1228

1229

Exceptions:

1230

Exceptions:

1230

Si un bloque leido no es un bloque valido

1231

Si un bloque leido no es un bloque valido

1231

"""

1232

"""

1232

1233

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

1234

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

1234

1235

try:

1236

try:

1236

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

1237

except:

1238

except:

1238

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

1239

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

1239

return 0

1240

return 0

1240

1241

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

1242

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

1242

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

1243

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

1243

1244

self.profileIndex = 0

1245

self.profileIndex = 0

1245

1246

self.flagIsNewFile = 0

1247

self.flagIsNewFile = 0

1247

self.flagIsNewBlock = 1

1248

self.flagIsNewBlock = 1

1248

1249

self.nTotalBlocks += 1

1250

self.nTotalBlocks += 1

1250

self.nReadBlocks += 1

1251

self.nReadBlocks += 1

1251

1252

return 1

1253

return 1

1253

1254

1255

def getData(self):

1256

def getData(self):

1256

"""

1257

"""

1257

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"

1258

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

1259

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"

1260

1261

Ademas incrementa el contador del buffer en 1.

1262

Ademas incrementa el contador del buffer en 1.

1262

1263

Return:

1264

Return:

1264

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

1265

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

1265

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

1266

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

1266

1267

Variables afectadas:

1268

Variables afectadas:

1268

self.dataOut

1269

self.dataOut

1269

self.profileIndex

1270

self.profileIndex

1270

1271

Affected:

1272

Affected:

1272

self.dataOut

1273

self.dataOut

1273

self.profileIndex

1274

self.profileIndex

1274

self.flagTimeBlock

1275

self.flagTimeBlock

1275

self.flagIsNewBlock

1276

self.flagIsNewBlock

1276

"""

1277

"""

1277

if self.flagNoMoreFiles: return 0

1278

if self.flagNoMoreFiles: return 0

1278

1279

self.flagTimeBlock = 0

1280

self.flagTimeBlock = 0

1280

self.flagIsNewBlock = 0

1281

self.flagIsNewBlock = 0

1281

1282

if self.__hasNotDataInBuffer():

1283

if self.__hasNotDataInBuffer():

1283

1284

if not( self.readNextBlock() ):

1285

if not( self.readNextBlock() ):

1285

return 0

1286

return 0

1286

1287

# self.updateDataHeader()

1288

# self.updateDataHeader()

1288

1289

if self.flagNoMoreFiles == 1:

1290

if self.flagNoMoreFiles == 1:

1290

print 'Process finished'

1291

print 'Process finished'

1291

return 0

1292

return 0

1292

1293

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

1294

1295

if self.datablock == None:

1296

if self.datablock == None:

1296

self.dataOut.flagNoData = True

1297

self.dataOut.flagNoData = True

1297

return 0

1298

return 0

1298

1299

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

1300

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

1300

1301

self.dataOut.dtype = self.dtype

1302

self.dataOut.dtype = self.dtype

1302

1303

self.dataOut.nChannels = self.systemHeaderObj.nChannels

1304

self.dataOut.nChannels = self.systemHeaderObj.nChannels

1304

1305

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1306

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1306

1307

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1308

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1308

1309

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

1310

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

1310

1311

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)

1312

1313

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

1314

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

1314

1315

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

1316

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

1316

1317

self.dataOut.flagTimeBlock = self.flagTimeBlock

1318

self.dataOut.flagTimeBlock = self.flagTimeBlock

1318

1319

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

1320

1321

self.dataOut.ippSeconds = self.ippSeconds

1322

self.dataOut.ippSeconds = self.ippSeconds

1322

1323

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

1324

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

1324

1325

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1326

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1326

1327

self.dataOut.flagShiftFFT = False

1328

self.dataOut.flagShiftFFT = False

1328

1329

if self.processingHeaderObj.code != None:

1330

if self.processingHeaderObj.code != None:

1330

self.dataOut.nCode = self.processingHeaderObj.nCode

1331

self.dataOut.nCode = self.processingHeaderObj.nCode

1331

1332

self.dataOut.nBaud = self.processingHeaderObj.nBaud

1333

self.dataOut.nBaud = self.processingHeaderObj.nBaud

1333

1334

self.dataOut.code = self.processingHeaderObj.code

1335

self.dataOut.code = self.processingHeaderObj.code

1335

1336

self.profileIndex += 1

1337

self.profileIndex += 1

1337

1338

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

1339

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

1339

1340

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

1341

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

1341

1342

self.dataOut.flagNoData = False

1343

self.dataOut.flagNoData = False

1343

1344

# print self.profileIndex, self.dataOut.utctime

1345

# print self.profileIndex, self.dataOut.utctime

1345

# if self.profileIndex == 800:

1346

# if self.profileIndex == 800:

1346

# a=1

1347

# a=1

1347

1348

return self.dataOut.data

1349

return self.dataOut.data

1349

1350

1351

class VoltageWriter(JRODataWriter):

1352

class VoltageWriter(JRODataWriter):

1352

"""

1353

"""

1353

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

1354

de los datos siempre se realiza por bloques.

1355

de los datos siempre se realiza por bloques.

1355

"""

1356

"""

1356

1357

ext = ".r"

1358

ext = ".r"

1358

1359

optchar = "D"

1360

optchar = "D"

1360

1361

shapeBuffer = None

1362

shapeBuffer = None

1362

1363

1364

def __init__(self, ~~dataOut~~=~~None~~):

1365

def __init__(self):

1365

"""

1366

"""

1366

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.

1367

1368

Affected:

1369

Affected:

1369

self.dataOut

1370

self.dataOut

1370

1371

Return: None

1372

Return: None

1372

"""

1373

"""

1373

if dataOut == None:

1374

dataOut = Voltage()

1375

1376

if not( isinstance(dataOut, Voltage) ):

1377

raise ValueError, "in VoltageReader, dataOut must be an Spectra class object"

1378

1379

self.dataOut = dataOut

1380

1374

1381

self.nTotalBlocks = 0

1375

self.nTotalBlocks = 0

1382

1376

1383

self.profileIndex = 0

1377

self.profileIndex = 0

1384

1378

1385

self.isConfig = False

1379

self.isConfig = False

1386

1380

1387

self.fp = None

1381

self.fp = None

1388

1382

1389

self.flagIsNewFile = 1

1383

self.flagIsNewFile = 1

1390

1384

1391

self.nTotalBlocks = 0

1385

self.nTotalBlocks = 0

1392

1386

1393

self.flagIsNewBlock = 0

1387

self.flagIsNewBlock = 0

1394

1388

1395

self.flagNoMoreFiles = 0

1389

self.flagNoMoreFiles = 0

1396

1390

1397

self.setFile = None

1391

self.setFile = None

1398

1392

1399

self.dtype = None

1393

self.dtype = None

1400

1394

1401

self.path = None

1395

self.path = None

1402

1396

1403

self.noMoreFiles = 0

1397

self.noMoreFiles = 0

1404

1398

1405

self.filename = None

1399

self.filename = None

1406

1400

1407

self.basicHeaderObj = BasicHeader()

1401

self.basicHeaderObj = BasicHeader()

1408

1402

1409

self.systemHeaderObj = SystemHeader()

1403

self.systemHeaderObj = SystemHeader()

1410

1404

1411

self.radarControllerHeaderObj = RadarControllerHeader()

1405

self.radarControllerHeaderObj = RadarControllerHeader()

1412

1406

1413

self.processingHeaderObj = ProcessingHeader()

1407

self.processingHeaderObj = ProcessingHeader()

1414

1408

1415

def hasAllDataInBuffer(self):

1409

def hasAllDataInBuffer(self):

1416

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

1410

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

1417

return 1

1411

return 1

1418

return 0

1412

return 0

1419

1413

1420

1414

1421

def setBlockDimension(self):

1415

def setBlockDimension(self):

1422

"""

1416

"""

1423

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

1424

1418

1425

Affected:

1419

Affected:

1426

self.shape_spc_Buffer

1420

self.shape_spc_Buffer

1427

self.shape_cspc_Buffer

1421

self.shape_cspc_Buffer

1428

self.shape_dc_Buffer

1422

self.shape_dc_Buffer

1429

1423

1430

Return: None

1424

Return: None

1431

"""

1425

"""

1432

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1426

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1433

self.processingHeaderObj.nHeights,

1427

self.processingHeaderObj.nHeights,

1434

self.systemHeaderObj.nChannels)

1428

self.systemHeaderObj.nChannels)

1435

1429

1436

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

1430

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

1437

self.processingHeaderObj.profilesPerBlock,

1431

self.processingHeaderObj.profilesPerBlock,

1438

self.processingHeaderObj.nHeights),

1432

self.processingHeaderObj.nHeights),

1439

dtype=numpy.dtype('complex'))

1433

dtype=numpy.dtype('complex'))

1440

1434

1441

1435

1442

def writeBlock(self):

1436

def writeBlock(self):

1443

"""

1437

"""

1444

Escribe el buffer en el file designado

1438

Escribe el buffer en el file designado

1445

1439

1446

Affected:

1440

Affected:

1447

self.profileIndex

1441

self.profileIndex

1448

self.flagIsNewFile

1442

self.flagIsNewFile

1449

self.flagIsNewBlock

1443

self.flagIsNewBlock

1450

self.nTotalBlocks

1444

self.nTotalBlocks

1451

self.blockIndex

1445

self.blockIndex

1452

1446

1453

Return: None

1447

Return: None

1454

"""

1448

"""

1455

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

1449

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

1456

1450

1457

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

1451

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

1458

1452

1459

data['real'] = junk.real

1453

data['real'] = junk.real

1460

data['imag'] = junk.imag

1454

data['imag'] = junk.imag

1461

1455

1462

data = data.reshape( (-1) )

1456

data = data.reshape( (-1) )

1463

1457

1464

data.tofile( self.fp )

1458

data.tofile( self.fp )

1465

1459

1466

self.datablock.fill(0)

1460

self.datablock.fill(0)

1467

1461

1468

self.profileIndex = 0

1462

self.profileIndex = 0

1469

self.flagIsNewFile = 0

1463

self.flagIsNewFile = 0

1470

self.flagIsNewBlock = 1

1464

self.flagIsNewBlock = 1

1471

1465

1472

self.blockIndex += 1

1466

self.blockIndex += 1

1473

self.nTotalBlocks += 1

1467

self.nTotalBlocks += 1

1474

1468

1475

def putData(self):

1469

def putData(self):

1476

"""

1470

"""

1477

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

1478

1472

1479

Affected:

1473

Affected:

1480

self.flagIsNewBlock

1474

self.flagIsNewBlock

1481

self.profileIndex

1475

self.profileIndex

1482

1476

1483

Return:

1477

Return:

1484

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

1485

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

1486

"""

1480

"""

1487

if self.dataOut.flagNoData:

1481

if self.dataOut.flagNoData:

1488

return 0

1482

return 0

1489

1483

1490

self.flagIsNewBlock = 0

1484

self.flagIsNewBlock = 0

1491

1485

1492

if self.dataOut.flagTimeBlock:

1486

if self.dataOut.flagTimeBlock:

1493

1487

1494

self.datablock.fill(0)

1488

self.datablock.fill(0)

1495

self.profileIndex = 0

1489

self.profileIndex = 0

1496

self.setNextFile()

1490

self.setNextFile()

1497

1491

1498

if self.profileIndex == 0:

1492

if self.profileIndex == 0:

1499

self.getBasicHeader()

1493

self.getBasicHeader()

1500

1494

1501

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

1495

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

1502

1496

1503

self.profileIndex += 1

1497

self.profileIndex += 1

1504

1498

1505

if self.hasAllDataInBuffer():

1499

if self.hasAllDataInBuffer():

1506

#if self.flagIsNewFile:

1500

#if self.flagIsNewFile:

1507

self.writeNextBlock()

1501

self.writeNextBlock()

1508

# self.getDataHeader()

1502

# self.getDataHeader()

1509

1503

1510

if self.flagNoMoreFiles:

1504

if self.flagNoMoreFiles:

1511

#print 'Process finished'

1505

#print 'Process finished'

1512

return 0

1506

return 0

1513

1507

1514

return 1

1508

return 1

1515

1509

1516

def __getProcessFlags(self):

1510

def __getProcessFlags(self):

1517

1511

1518

processFlags = 0

1512

processFlags = 0

1519

1513

1520

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

1514

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

1521

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

1515

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

1522

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

1516

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

1523

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

1517

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

1524

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

1518

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

1525

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

1519

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

1526

1520

1527

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

1521

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

1528

1522

1529

1523

1530

1524

1531

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1525

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1532

PROCFLAG.DATATYPE_SHORT,

1526

PROCFLAG.DATATYPE_SHORT,

1533

PROCFLAG.DATATYPE_LONG,

1527

PROCFLAG.DATATYPE_LONG,

1534

PROCFLAG.DATATYPE_INT64,

1528

PROCFLAG.DATATYPE_INT64,

1535

PROCFLAG.DATATYPE_FLOAT,

1529

PROCFLAG.DATATYPE_FLOAT,

1536

PROCFLAG.DATATYPE_DOUBLE]

1530

PROCFLAG.DATATYPE_DOUBLE]

1537

1531

1538

1532

1539

for index in range(len(dtypeList)):

1533

for index in range(len(dtypeList)):

1540

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

1534

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

1541

dtypeValue = datatypeValueList[index]

1535

dtypeValue = datatypeValueList[index]

1542

break

1536

break

1543

1537

1544

processFlags += dtypeValue

1538

processFlags += dtypeValue

1545

1539

1546

if self.dataOut.flagDecodeData:

1540

if self.dataOut.flagDecodeData:

1547

processFlags += PROCFLAG.DECODE_DATA

1541

processFlags += PROCFLAG.DECODE_DATA

1548

1542

1549

if self.dataOut.flagDeflipData:

1543

if self.dataOut.flagDeflipData:

1550

processFlags += PROCFLAG.DEFLIP_DATA

1544

processFlags += PROCFLAG.DEFLIP_DATA

1551

1545

1552

if self.dataOut.code != None:

1546

if self.dataOut.code != None:

1553

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1547

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1554

1548

1555

if self.dataOut.nCohInt > 1:

1549

if self.dataOut.nCohInt > 1:

1556

processFlags += PROCFLAG.COHERENT_INTEGRATION

1550

processFlags += PROCFLAG.COHERENT_INTEGRATION

1557

1551

1558

return processFlags

1552

return processFlags

1559

1553

1560

1554

1561

def __getBlockSize(self):

1555

def __getBlockSize(self):

1562

'''

1556

'''

1563

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

1564

'''

1558

'''

1565

1559

1566

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

1560

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

1567

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

1561

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

1568

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

1562

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

1569

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

1563

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

1570

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

1564

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

1571

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

1565

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

1572

1566

1573

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

1567

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

1574

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

1568

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

1575

for index in range(len(dtypeList)):

1569

for index in range(len(dtypeList)):

1576

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

1570

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

1577

datatypeValue = datatypeValueList[index]

1571

datatypeValue = datatypeValueList[index]

1578

break

1572

break

1579

1573

1580

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)

1581

1575

1582

return blocksize

1576

return blocksize

1583

1577

1584

def getDataHeader(self):

1578

def getDataHeader(self):

1585

1579

1586

"""

1580

"""

1587

Obtiene una copia del First Header

1581

Obtiene una copia del First Header

1588

1582

1589

Affected:

1583

Affected:

1590

self.systemHeaderObj

1584

self.systemHeaderObj

1591

self.radarControllerHeaderObj

1585

self.radarControllerHeaderObj

1592

self.dtype

1586

self.dtype

1593

1587

1594

Return:

1588

Return:

1595

None

1589

None

1596

"""

1590

"""

1597

1591

1598

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

1592

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

1599

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1593

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1600

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

1594

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

1601

1595

1602

self.getBasicHeader()

1596

self.getBasicHeader()

1603

1597

1604

processingHeaderSize = 40 # bytes

1598

processingHeaderSize = 40 # bytes

1605

self.processingHeaderObj.dtype = 0 # Voltage

1599

self.processingHeaderObj.dtype = 0 # Voltage

1606

self.processingHeaderObj.blockSize = self.__getBlockSize()

1600

self.processingHeaderObj.blockSize = self.__getBlockSize()

1607

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1601

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1608

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1602

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1609

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

1610

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1604

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1611

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1605

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1612

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

1613

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

1614

1608

1615

if self.dataOut.code != None:

1609

if self.dataOut.code != None:

1616

self.processingHeaderObj.code = self.dataOut.code

1610

self.processingHeaderObj.code = self.dataOut.code

1617

self.processingHeaderObj.nCode = self.dataOut.nCode

1611

self.processingHeaderObj.nCode = self.dataOut.nCode

1618

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1612

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1619

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

1613

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

1620

processingHeaderSize += codesize

1614

processingHeaderSize += codesize

1621

1615

1622

if self.processingHeaderObj.nWindows != 0:

1616

if self.processingHeaderObj.nWindows != 0:

1623

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

1617

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

1624

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

1618

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

1625

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1619

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1626

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1620

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1627

processingHeaderSize += 12

1621

processingHeaderSize += 12

1628

1622

1629

self.processingHeaderObj.size = processingHeaderSize

1623

self.processingHeaderObj.size = processingHeaderSize

1630

1624

1631

class SpectraReader(JRODataReader):

1625

class SpectraReader(JRODataReader):

1632

"""

1626

"""

1633

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

1634

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)

1635

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.

1636

1630

1637

paresCanalesIguales * alturas * perfiles (Self Spectra)

1631

paresCanalesIguales * alturas * perfiles (Self Spectra)

1638

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1632

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1639

canales * alturas (DC Channels)

1633

canales * alturas (DC Channels)

1640

1634

1641

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

1635

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

1642

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

1643

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

1644

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

1645

1639

1646

Example:

1640

Example:

1647

dpath = "/home/myuser/data"

1641

dpath = "/home/myuser/data"

1648

1642

1649

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)

1650

1644

1651

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)

1652

1646

1653

readerObj = SpectraReader()

1647

readerObj = SpectraReader()

1654

1648

1655

readerObj.setup(dpath, startTime, endTime)

1649

readerObj.setup(dpath, startTime, endTime)

1656

1650

1657

while(True):

1651

while(True):

1658

1652

1659

readerObj.getData()

1653

readerObj.getData()

1660

1654

1661

print readerObj.data_spc

1655

print readerObj.data_spc

1662

1656

1663

print readerObj.data_cspc

1657

print readerObj.data_cspc

1664

1658

1665

print readerObj.data_dc

1659

print readerObj.data_dc

1666

1660

1667

if readerObj.flagNoMoreFiles:

1661

if readerObj.flagNoMoreFiles:

1668

break

1662

break

1669

1663

1670

"""

1664

"""

1671

1665

1672

pts2read_SelfSpectra = 0

1666

pts2read_SelfSpectra = 0

1673

1667

1674

pts2read_CrossSpectra = 0

1668

pts2read_CrossSpectra = 0

1675

1669

1676

pts2read_DCchannels = 0

1670

pts2read_DCchannels = 0

1677

1671

1678

ext = ".pdata"

1672

ext = ".pdata"

1679

1673

1680

optchar = "P"

1674

optchar = "P"

1681

1675

1682

dataOut = None

1676

dataOut = None

1683

1677

1684

nRdChannels = None

1678

nRdChannels = None

1685

1679

1686

nRdPairs = None

1680

nRdPairs = None

1687

1681

1688

rdPairList = []

1682

rdPairList = []

1689

1683

1690

1684

1691

def __init__(self, ~~dataOut~~=~~None~~):

1685

def __init__(self):

1692

"""

1686

"""

1693

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.

1694

1688

1695

Inputs:

1689

Inputs:

1696

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

1690

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

1697

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

1698

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

1692

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

1699

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

1700

bloque de datos.

1694

bloque de datos.

1701

Si este parametro no es pasado se creara uno internamente.

1695

Si este parametro no es pasado se creara uno internamente.

1702

1696

1703

Affected:

1697

Affected:

1704

self.dataOut

1698

self.dataOut

1705

1699

1706

Return : None

1700

Return : None

1707

"""

1701

"""

1708

1702

1709

self.isConfig = False

1703

self.isConfig = False

1710

1704

1711

self.pts2read_SelfSpectra = 0

1705

self.pts2read_SelfSpectra = 0

1712

1706

1713

self.pts2read_CrossSpectra = 0

1707

self.pts2read_CrossSpectra = 0

1714

1708

1715

self.pts2read_DCchannels = 0

1709

self.pts2read_DCchannels = 0

1716

1710

1717

self.datablock = None

1711

self.datablock = None

1718

1712

1719

self.utc = None

1713

self.utc = None

1720

1714

1721

self.ext = ".pdata"

1715

self.ext = ".pdata"

1722

1716

1723

self.optchar = "P"

1717

self.optchar = "P"

1724

1718

1725

self.basicHeaderObj = BasicHeader()

1719

self.basicHeaderObj = BasicHeader()

1726

1720

1727

self.systemHeaderObj = SystemHeader()

1721

self.systemHeaderObj = SystemHeader()

1728

1722

1729

self.radarControllerHeaderObj = RadarControllerHeader()

1723

self.radarControllerHeaderObj = RadarControllerHeader()

1730

1724

1731

self.processingHeaderObj = ProcessingHeader()

1725

self.processingHeaderObj = ProcessingHeader()

1732

1726

1733

self.online = 0

1727

self.online = 0

1734

1728

1735

self.fp = None

1729

self.fp = None

1736

1730

1737

self.idFile = None

1731

self.idFile = None

1738

1732

1739

self.dtype = None

1733

self.dtype = None

1740

1734

1741

self.fileSizeByHeader = None

1735

self.fileSizeByHeader = None

1742

1736

1743

self.filenameList = []

1737

self.filenameList = []

1744

1738

1745

self.filename = None

1739

self.filename = None

1746

1740

1747

self.fileSize = None

1741

self.fileSize = None

1748

1742

1749

self.firstHeaderSize = 0

1743

self.firstHeaderSize = 0

1750

1744

1751

self.basicHeaderSize = 24

1745

self.basicHeaderSize = 24

1752

1746

1753

self.pathList = []

1747

self.pathList = []

1754

1748

1755

self.lastUTTime = 0

1749

self.lastUTTime = 0

1756

1750

1757

self.maxTimeStep = 30

1751

self.maxTimeStep = 30

1758

1752

1759

self.flagNoMoreFiles = 0

1753

self.flagNoMoreFiles = 0

1760

1754

1761

self.set = 0

1755

self.set = 0

1762

1756

1763

self.path = None

1757

self.path = None

1764

1758

1765

self.delay = 3 #seconds

1759

self.delay = 3 #seconds

1766

1760

1767

self.nTries = 3 #quantity tries

1761

self.nTries = 3 #quantity tries

1768

1762

1769

self.nFiles = 3 #number of files for searching

1763

self.nFiles = 3 #number of files for searching

1770

1764

1771

self.nReadBlocks = 0

1765

self.nReadBlocks = 0

1772

1766

1773

self.flagIsNewFile = 1

1767

self.flagIsNewFile = 1

1774

1768

1775

self.ippSeconds = 0

1769

self.ippSeconds = 0

1776

1770

1777

self.flagTimeBlock = 0

1771

self.flagTimeBlock = 0

1778

1772

1779

self.flagIsNewBlock = 0

1773

self.flagIsNewBlock = 0

1780

1774

1781

self.nTotalBlocks = 0

1775

self.nTotalBlocks = 0

1782

1776

1783

self.blocksize = 0

1777

self.blocksize = 0

1778

1779

dataOut = self.createObjByDefault()

1784

1780

1785

1781

1786

def createObjByDefault(self):

1782

def createObjByDefault(self):

1787

1783

1788

dataObj = Spectra()

1784

dataObj = Spectra()

1789

1785

1790

return dataObj

1786

return dataObj

1791

1787

1792

def __hasNotDataInBuffer(self):

1788

def __hasNotDataInBuffer(self):

1793

return 1

1789

return 1

1794

1790

1795

1791

1796

def getBlockDimension(self):

1792

def getBlockDimension(self):

1797

"""

1793

"""

1798

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

1799

1795

1800

Affected:

1796

Affected:

1801

self.nRdChannels

1797

self.nRdChannels

1802

self.nRdPairs

1798

self.nRdPairs

1803

self.pts2read_SelfSpectra

1799

self.pts2read_SelfSpectra

1804

self.pts2read_CrossSpectra

1800

self.pts2read_CrossSpectra

1805

self.pts2read_DCchannels

1801

self.pts2read_DCchannels

1806

self.blocksize

1802

self.blocksize

1807

self.dataOut.nChannels

1803

self.dataOut.nChannels

1808

self.dataOut.nPairs

1804

self.dataOut.nPairs

1809

1805

1810

Return:

1806

Return:

1811

None

1807

None

1812

"""

1808

"""

1813

self.nRdChannels = 0

1809

self.nRdChannels = 0

1814

self.nRdPairs = 0

1810

self.nRdPairs = 0

1815

self.rdPairList = []

1811

self.rdPairList = []

1816

1812

1817

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

1813

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

1818

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

1814

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

1819

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

1815

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

1820

else:

1816

else:

1821

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

1817

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

1822

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

1823

1819

1824

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

1820

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

1825

1821

1826

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

1822

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

1827

self.blocksize = self.pts2read_SelfSpectra

1823

self.blocksize = self.pts2read_SelfSpectra

1828

1824

1829

if self.processingHeaderObj.flag_cspc:

1825

if self.processingHeaderObj.flag_cspc:

1830

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

1826

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

1831

self.blocksize += self.pts2read_CrossSpectra

1827

self.blocksize += self.pts2read_CrossSpectra

1832

1828

1833

if self.processingHeaderObj.flag_dc:

1829

if self.processingHeaderObj.flag_dc:

1834

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

1830

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

1835

self.blocksize += self.pts2read_DCchannels

1831

self.blocksize += self.pts2read_DCchannels

1836

1832

1837

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

1833

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

1838

1834

1839

1835

1840

def readBlock(self):

1836

def readBlock(self):

1841

"""

1837

"""

1842

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

1843

(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

1844

(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

1845

es seteado a 0

1841

es seteado a 0

1846

1842

1847

Return: None

1843

Return: None

1848

1844

1849

Variables afectadas:

1845

Variables afectadas:

1850

1846

1851

self.flagIsNewFile

1847

self.flagIsNewFile

1852

self.flagIsNewBlock

1848

self.flagIsNewBlock

1853

self.nTotalBlocks

1849

self.nTotalBlocks

1854

self.data_spc

1850

self.data_spc

1855

self.data_cspc

1851

self.data_cspc

1856

self.data_dc

1852

self.data_dc

1857

1853

1858

Exceptions:

1854

Exceptions:

1859

Si un bloque leido no es un bloque valido

1855

Si un bloque leido no es un bloque valido

1860

"""

1856

"""

1861

blockOk_flag = False

1857

blockOk_flag = False

1862

fpointer = self.fp.tell()

1858

fpointer = self.fp.tell()

1863

1859

1864

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

1860

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

1865

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

1866

1862

1867

if self.processingHeaderObj.flag_cspc:

1863

if self.processingHeaderObj.flag_cspc:

1868

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

1864

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

1869

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

1870

1866

1871

if self.processingHeaderObj.flag_dc:

1867

if self.processingHeaderObj.flag_dc:

1872

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

1873

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

1874

1870

1875

1871

1876

if not(self.processingHeaderObj.shif_fft):

1872

if not(self.processingHeaderObj.shif_fft):

1877

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

1878

1874

1879

if self.processingHeaderObj.flag_cspc:

1875

if self.processingHeaderObj.flag_cspc:

1880

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

1881

1877

1882

1878

1883

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

1879

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

1884

self.data_spc = spc

1880

self.data_spc = spc

1885

1881

1886

if self.processingHeaderObj.flag_cspc:

1882

if self.processingHeaderObj.flag_cspc:

1887

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

1883

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

1888

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

1884

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

1889

else:

1885

else:

1890

self.data_cspc = None

1886

self.data_cspc = None

1891

1887

1892

if self.processingHeaderObj.flag_dc:

1888

if self.processingHeaderObj.flag_dc:

1893

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

1889

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

1894

else:

1890

else:

1895

self.data_dc = None

1891

self.data_dc = None

1896

1892

1897

self.flagIsNewFile = 0

1893

self.flagIsNewFile = 0

1898

self.flagIsNewBlock = 1

1894

self.flagIsNewBlock = 1

1899

1895

1900

self.nTotalBlocks += 1

1896

self.nTotalBlocks += 1

1901

self.nReadBlocks += 1

1897

self.nReadBlocks += 1

1902

1898

1903

return 1

1899

return 1

1904

1900

1905

1901

1906

def getData(self):

1902

def getData(self):

1907

"""

1903

"""

1908

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

1904

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

1909

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

1910

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"

1911

1907

1912

Return:

1908

Return:

1913

0 : Si no hay mas archivos disponibles

1909

0 : Si no hay mas archivos disponibles

1914

1 : Si hizo una buena copia del buffer

1910

1 : Si hizo una buena copia del buffer

1915

1911

1916

Affected:

1912

Affected:

1917

self.dataOut

1913

self.dataOut

1918

1914

1919

self.flagTimeBlock

1915

self.flagTimeBlock

1920

self.flagIsNewBlock

1916

self.flagIsNewBlock

1921

"""

1917

"""

1922

1918

1923

if self.flagNoMoreFiles: return 0

1919

if self.flagNoMoreFiles: return 0

1924

1920

1925

self.flagTimeBlock = 0

1921

self.flagTimeBlock = 0

1926

self.flagIsNewBlock = 0

1922

self.flagIsNewBlock = 0

1927

1923

1928

if self.__hasNotDataInBuffer():

1924

if self.__hasNotDataInBuffer():

1929

1925

1930

if not( self.readNextBlock() ):

1926

if not( self.readNextBlock() ):

1931

return 0

1927

return 0

1932

1928

1933

# self.updateDataHeader()

1929

# self.updateDataHeader()

1934

1930

1935

if self.flagNoMoreFiles == 1:

1931

if self.flagNoMoreFiles == 1:

1936

print 'Process finished'

1932

print 'Process finished'

1937

return 0

1933

return 0

1938

1934

1939

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

1940

1936

1941

if self.data_dc == None:

1937

if self.data_dc == None:

1942

self.dataOut.flagNoData = True

1938

self.dataOut.flagNoData = True

1943

return 0

1939

return 0

1944

1940

1945

1941

1946

self.dataOut.data_spc = self.data_spc

1942

self.dataOut.data_spc = self.data_spc

1947

1943

1948

self.dataOut.data_cspc = self.data_cspc

1944

self.dataOut.data_cspc = self.data_cspc

1949

1945

1950

self.dataOut.data_dc = self.data_dc

1946

self.dataOut.data_dc = self.data_dc

1951

1947

1952

self.dataOut.flagTimeBlock = self.flagTimeBlock

1948

self.dataOut.flagTimeBlock = self.flagTimeBlock

1953

1949

1954

self.dataOut.flagNoData = False

1950

self.dataOut.flagNoData = False

1955

1951

1956

self.dataOut.dtype = self.dtype

1952

self.dataOut.dtype = self.dtype

1957

1953

1958

self.dataOut.nChannels = self.nRdChannels

1954

self.dataOut.nChannels = self.nRdChannels

1959

1955

1960

self.dataOut.nPairs = self.nRdPairs

1956

self.dataOut.nPairs = self.nRdPairs

1961

1957

1962

self.dataOut.pairsList = self.rdPairList

1958

self.dataOut.pairsList = self.rdPairList

1963

1959

1964

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1960

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1965

1961

1966

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1962

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1967

1963

1968

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

1964

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

1969

1965

1970

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

1966

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

1971

1967

1972

1968

1973

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

1969

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

1974

1970

1975

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)

1976

1972

1977

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

1973

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

1978

1974

1979

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

1975

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

1980

1976

1981

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

1982

1978

1983

self.dataOut.ippSeconds = self.ippSeconds

1979

self.dataOut.ippSeconds = self.ippSeconds

1984

1980

1985

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

1986

1982

1987

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

1983

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

1988

1984

1989

# self.profileIndex += 1

1985

# self.profileIndex += 1

1990

1986

1991

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

1987

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

1992

1988

1993

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

1989

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

1994

1990

1995

return self.dataOut.data_spc

1991

return self.dataOut.data_spc

1996

1992

1997

1993

1998

class SpectraWriter(JRODataWriter):

1994

class SpectraWriter(JRODataWriter):

1999

1995

2000

"""

1996

"""

2001

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

2002

de los datos siempre se realiza por bloques.

1998

de los datos siempre se realiza por bloques.

2003

"""

1999

"""

2004

2000

2005

ext = ".pdata"

2001

ext = ".pdata"

2006

2002

2007

optchar = "P"

2003

optchar = "P"

2008

2004

2009

shape_spc_Buffer = None

2005

shape_spc_Buffer = None

2010

2006

2011

shape_cspc_Buffer = None

2007

shape_cspc_Buffer = None

2012

2008

2013

shape_dc_Buffer = None

2009

shape_dc_Buffer = None

2014

2010

2015

data_spc = None

2011

data_spc = None

2016

2012

2017

data_cspc = None

2013

data_cspc = None

2018

2014

2019

data_dc = None

2015

data_dc = None

2020

2016

2021

# dataOut = None

2017

# dataOut = None

2022

2018

2023

def __init__(self, ~~dataOut~~=~~None~~):

2019

def __init__(self):

2024

"""

2020

"""

2025

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.

2026

2022

2027

Affected:

2023

Affected:

2028

self.dataOut

2024

self.dataOut

2029

self.basicHeaderObj

2025

self.basicHeaderObj

2030

self.systemHeaderObj

2026

self.systemHeaderObj

2031

self.radarControllerHeaderObj

2027

self.radarControllerHeaderObj

2032

self.processingHeaderObj

2028

self.processingHeaderObj

2033

2029

2034

Return: None

2030

Return: None

2035

"""

2031

"""

2036

if dataOut == None:

2037

dataOut = Spectra()

2038

2039

if not( isinstance(dataOut, Spectra) ):

2040

raise ValueError, "in SpectraReader, dataOut must be an Spectra class object"

2041

2042

self.dataOut = dataOut

2043

2032

2044

self.isConfig = False

2033

self.isConfig = False

2045

2034

2046

self.nTotalBlocks = 0

2035

self.nTotalBlocks = 0

2047

2036

2048

self.data_spc = None

2037

self.data_spc = None

2049

2038

2050

self.data_cspc = None

2039

self.data_cspc = None

2051

2040

2052

self.data_dc = None

2041

self.data_dc = None

2053

2042

2054

self.fp = None

2043

self.fp = None

2055

2044

2056

self.flagIsNewFile = 1

2045

self.flagIsNewFile = 1

2057

2046

2058

self.nTotalBlocks = 0

2047

self.nTotalBlocks = 0

2059

2048

2060

self.flagIsNewBlock = 0

2049

self.flagIsNewBlock = 0

2061

2050

2062

self.flagNoMoreFiles = 0

2051

self.flagNoMoreFiles = 0

2063

2052

2064

self.setFile = None

2053

self.setFile = None

2065

2054

2066

self.dtype = None

2055

self.dtype = None

2067

2056

2068

self.path = None

2057

self.path = None

2069

2058

2070

self.noMoreFiles = 0

2059

self.noMoreFiles = 0

2071

2060

2072

self.filename = None

2061

self.filename = None

2073

2062

2074

self.basicHeaderObj = BasicHeader()

2063

self.basicHeaderObj = BasicHeader()

2075

2064

2076

self.systemHeaderObj = SystemHeader()

2065

self.systemHeaderObj = SystemHeader()

2077

2066

2078

self.radarControllerHeaderObj = RadarControllerHeader()

2067

self.radarControllerHeaderObj = RadarControllerHeader()

2079

2068

2080

self.processingHeaderObj = ProcessingHeader()

2069

self.processingHeaderObj = ProcessingHeader()

2081

2070

2082

2071

2083

def hasAllDataInBuffer(self):

2072

def hasAllDataInBuffer(self):

2084

return 1

2073

return 1

2085

2074

2086

2075

2087

def setBlockDimension(self):

2076

def setBlockDimension(self):

2088

"""

2077

"""

2089

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

2090

2079

2091

Affected:

2080

Affected:

2092

self.shape_spc_Buffer

2081

self.shape_spc_Buffer

2093

self.shape_cspc_Buffer

2082

self.shape_cspc_Buffer

2094

self.shape_dc_Buffer

2083

self.shape_dc_Buffer

2095

2084

2096

Return: None

2085

Return: None

2097

"""

2086

"""

2098

self.shape_spc_Buffer = (self.dataOut.nChannels,

2087

self.shape_spc_Buffer = (self.dataOut.nChannels,

2099

self.processingHeaderObj.nHeights,

2088

self.processingHeaderObj.nHeights,

2100

self.processingHeaderObj.profilesPerBlock)

2089

self.processingHeaderObj.profilesPerBlock)

2101

2090

2102

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2091

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2103

self.processingHeaderObj.nHeights,

2092

self.processingHeaderObj.nHeights,

2104

self.processingHeaderObj.profilesPerBlock)

2093

self.processingHeaderObj.profilesPerBlock)

2105

2094

2106

self.shape_dc_Buffer = (self.dataOut.nChannels,

2095

self.shape_dc_Buffer = (self.dataOut.nChannels,

2107

self.processingHeaderObj.nHeights)

2096

self.processingHeaderObj.nHeights)

2108

2097

2109

2098

2110

def writeBlock(self):

2099

def writeBlock(self):

2111

"""

2100

"""

2112

Escribe el buffer en el file designado

2101

Escribe el buffer en el file designado

2113

2102

2114

Affected:

2103

Affected:

2115

self.data_spc

2104

self.data_spc

2116

self.data_cspc

2105

self.data_cspc

2117

self.data_dc

2106

self.data_dc

2118

self.flagIsNewFile

2107

self.flagIsNewFile

2119

self.flagIsNewBlock

2108

self.flagIsNewBlock

2120

self.nTotalBlocks

2109

self.nTotalBlocks

2121

self.nWriteBlocks

2110

self.nWriteBlocks

2122

2111

2123

Return: None

2112

Return: None

2124

"""

2113

"""

2125

2114

2126

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

2115

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

2127

if not( self.processingHeaderObj.shif_fft ):

2116

if not( self.processingHeaderObj.shif_fft ):

2128

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

2129

data = spc.reshape((-1))

2118

data = spc.reshape((-1))

2130

data.tofile(self.fp)

2119

data.tofile(self.fp)

2131

2120

2132

if self.data_cspc != None:

2121

if self.data_cspc != None:

2133

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

2122

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

2134

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

2123

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

2135

if not( self.processingHeaderObj.shif_fft ):

2124

if not( self.processingHeaderObj.shif_fft ):

2136

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

2137

data['real'] = cspc.real

2126

data['real'] = cspc.real

2138

data['imag'] = cspc.imag

2127

data['imag'] = cspc.imag

2139

data = data.reshape((-1))

2128

data = data.reshape((-1))

2140

data.tofile(self.fp)

2129

data.tofile(self.fp)

2141

2130

2142

if self.data_dc != None:

2131

if self.data_dc != None:

2143

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

2132

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

2144

dc = self.data_dc

2133

dc = self.data_dc

2145

data['real'] = dc.real

2134

data['real'] = dc.real

2146

data['imag'] = dc.imag

2135

data['imag'] = dc.imag

2147

data = data.reshape((-1))

2136

data = data.reshape((-1))

2148

data.tofile(self.fp)

2137

data.tofile(self.fp)

2149

2138

2150

self.data_spc.fill(0)

2139

self.data_spc.fill(0)

2151

self.data_dc.fill(0)

2140

self.data_dc.fill(0)

2152

if self.data_cspc != None:

2141

if self.data_cspc != None:

2153

self.data_cspc.fill(0)

2142

self.data_cspc.fill(0)

2154

2143

2155

self.flagIsNewFile = 0

2144

self.flagIsNewFile = 0

2156

self.flagIsNewBlock = 1

2145

self.flagIsNewBlock = 1

2157

self.nTotalBlocks += 1

2146

self.nTotalBlocks += 1

2158

self.nWriteBlocks += 1

2147

self.nWriteBlocks += 1

2159

self.blockIndex += 1

2148

self.blockIndex += 1

2160

2149

2161

2150

2162

def putData(self):

2151

def putData(self):

2163

"""

2152

"""

2164

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

2165

2154

2166

Affected:

2155

Affected:

2167

self.data_spc

2156

self.data_spc

2168

self.data_cspc

2157

self.data_cspc

2169

self.data_dc

2158

self.data_dc

2170

2159

2171

Return:

2160

Return:

2172

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

2173

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

2174

"""

2163

"""

2175

2164

2176

if self.dataOut.flagNoData:

2165

if self.dataOut.flagNoData:

2177

return 0

2166

return 0

2178

2167

2179

self.flagIsNewBlock = 0

2168

self.flagIsNewBlock = 0

2180

2169

2181

if self.dataOut.flagTimeBlock:

2170

if self.dataOut.flagTimeBlock:

2182

self.data_spc.fill(0)

2171

self.data_spc.fill(0)

2183

self.data_cspc.fill(0)

2172

self.data_cspc.fill(0)

2184

self.data_dc.fill(0)

2173

self.data_dc.fill(0)

2185

self.setNextFile()

2174

self.setNextFile()

2186

2175

2187

if self.flagIsNewFile == 0:

2176

if self.flagIsNewFile == 0:

2188

self.getBasicHeader()

2177

self.getBasicHeader()

2189

2178

2190

self.data_spc = self.dataOut.data_spc

2179

self.data_spc = self.dataOut.data_spc

2191

self.data_cspc = self.dataOut.data_cspc

2180

self.data_cspc = self.dataOut.data_cspc

2192

self.data_dc = self.dataOut.data_dc

2181

self.data_dc = self.dataOut.data_dc

2193

2182

2194

# #self.processingHeaderObj.dataBlocksPerFile)

2183

# #self.processingHeaderObj.dataBlocksPerFile)

2195

if self.hasAllDataInBuffer():

2184

if self.hasAllDataInBuffer():

2196

# self.getDataHeader()

2185

# self.getDataHeader()

2197

self.writeNextBlock()

2186

self.writeNextBlock()

2198

2187

2199

if self.flagNoMoreFiles:

2188

if self.flagNoMoreFiles:

2200

#print 'Process finished'

2189

#print 'Process finished'

2201

return 0

2190

return 0

2202

2191

2203

return 1

2192

return 1

2204

2193

2205

2194

2206

def __getProcessFlags(self):

2195

def __getProcessFlags(self):

2207

2196

2208

processFlags = 0

2197

processFlags = 0

2209

2198

2210

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

2199

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

2211

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

2200

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

2212

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

2201

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

2213

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

2202

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

2214

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

2203

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

2215

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

2204

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

2216

2205

2217

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

2206

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

2218

2207

2219

2208

2220

2209

2221

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2210

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2222

PROCFLAG.DATATYPE_SHORT,

2211

PROCFLAG.DATATYPE_SHORT,

2223

PROCFLAG.DATATYPE_LONG,

2212

PROCFLAG.DATATYPE_LONG,

2224

PROCFLAG.DATATYPE_INT64,

2213

PROCFLAG.DATATYPE_INT64,

2225

PROCFLAG.DATATYPE_FLOAT,

2214

PROCFLAG.DATATYPE_FLOAT,

2226

PROCFLAG.DATATYPE_DOUBLE]

2215

PROCFLAG.DATATYPE_DOUBLE]

2227

2216

2228

2217

2229

for index in range(len(dtypeList)):

2218

for index in range(len(dtypeList)):

2230

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

2219

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

2231

dtypeValue = datatypeValueList[index]

2220

dtypeValue = datatypeValueList[index]

2232

break

2221

break

2233

2222

2234

processFlags += dtypeValue

2223

processFlags += dtypeValue

2235

2224

2236

if self.dataOut.flagDecodeData:

2225

if self.dataOut.flagDecodeData:

2237

processFlags += PROCFLAG.DECODE_DATA

2226

processFlags += PROCFLAG.DECODE_DATA

2238

2227

2239

if self.dataOut.flagDeflipData:

2228

if self.dataOut.flagDeflipData:

2240

processFlags += PROCFLAG.DEFLIP_DATA

2229

processFlags += PROCFLAG.DEFLIP_DATA

2241

2230

2242

if self.dataOut.code != None:

2231

if self.dataOut.code != None:

2243

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2232

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2244

2233

2245

if self.dataOut.nIncohInt > 1:

2234

if self.dataOut.nIncohInt > 1:

2246

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2235

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2247

2236

2248

if self.dataOut.data_dc != None:

2237

if self.dataOut.data_dc != None:

2249

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2238

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2250

2239

2251

return processFlags

2240

return processFlags

2252

2241

2253

2242

2254

def __getBlockSize(self):

2243

def __getBlockSize(self):

2255

'''

2244

'''

2256

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

2257

'''

2246

'''

2258

2247

2259

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

2248

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

2260

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

2249

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

2261

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

2250

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

2262

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

2251

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

2263

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

2252

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

2264

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

2253

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

2265

2254

2266

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

2255

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

2267

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

2256

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

2268

for index in range(len(dtypeList)):

2257

for index in range(len(dtypeList)):

2269

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

2258

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

2270

datatypeValue = datatypeValueList[index]

2259

datatypeValue = datatypeValueList[index]

2271

break

2260

break

2272

2261

2273

2262

2274

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

2263

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

2275

2264

2276

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

2265

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

2277

blocksize = (pts2write_SelfSpectra*datatypeValue)

2266

blocksize = (pts2write_SelfSpectra*datatypeValue)

2278

2267

2279

if self.dataOut.data_cspc != None:

2268

if self.dataOut.data_cspc != None:

2280

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

2269

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

2281

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2270

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2282

2271

2283

if self.dataOut.data_dc != None:

2272

if self.dataOut.data_dc != None:

2284

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

2273

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

2285

blocksize += (pts2write_DCchannels*datatypeValue*2)

2274

blocksize += (pts2write_DCchannels*datatypeValue*2)

2286

2275

2287

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2276

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2288

2277

2289

return blocksize

2278

return blocksize

2290

2279

2291

def getDataHeader(self):

2280

def getDataHeader(self):

2292

2281

2293

"""

2282

"""

2294

Obtiene una copia del First Header

2283

Obtiene una copia del First Header

2295

2284

2296

Affected:

2285

Affected:

2297

self.systemHeaderObj

2286

self.systemHeaderObj

2298

self.radarControllerHeaderObj

2287

self.radarControllerHeaderObj

2299

self.dtype

2288

self.dtype

2300

2289

2301

Return:

2290

Return:

2302

None

2291

None

2303

"""

2292

"""

2304

2293

2305

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

2294

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

2306

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2295

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2307

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

2296

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

2308

2297

2309

self.getBasicHeader()

2298

self.getBasicHeader()

2310

2299

2311

processingHeaderSize = 40 # bytes

2300

processingHeaderSize = 40 # bytes

2312

self.processingHeaderObj.dtype = 0 # Voltage

2301

self.processingHeaderObj.dtype = 0 # Voltage

2313

self.processingHeaderObj.blockSize = self.__getBlockSize()

2302

self.processingHeaderObj.blockSize = self.__getBlockSize()

2314

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2303

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2315

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2304

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2316

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

2317

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2306

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2318

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

2319

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2308

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2320

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

2309

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

2321

2310

2322

if self.processingHeaderObj.totalSpectra > 0:

2311

if self.processingHeaderObj.totalSpectra > 0:

2323

channelList = []

2312

channelList = []

2324

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

2313

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

2325

channelList.append(channel)

2314

channelList.append(channel)

2326

channelList.append(channel)

2315

channelList.append(channel)

2327

2316

2328

pairsList = []

2317

pairsList = []

2329

for pair in self.dataOut.pairsList:

2318

for pair in self.dataOut.pairsList:

2330

pairsList.append(pair[0])

2319

pairsList.append(pair[0])

2331

pairsList.append(pair[1])

2320

pairsList.append(pair[1])

2332

spectraComb = channelList + pairsList

2321

spectraComb = channelList + pairsList

2333

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

2322

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

2334

self.processingHeaderObj.spectraComb = spectraComb

2323

self.processingHeaderObj.spectraComb = spectraComb

2335

sizeOfSpcComb = len(spectraComb)

2324

sizeOfSpcComb = len(spectraComb)

2336

processingHeaderSize += sizeOfSpcComb

2325

processingHeaderSize += sizeOfSpcComb

2337

2326

2338

if self.dataOut.code != None:

2327

if self.dataOut.code != None:

2339

self.processingHeaderObj.code = self.dataOut.code

2328

self.processingHeaderObj.code = self.dataOut.code

2340

self.processingHeaderObj.nCode = self.dataOut.nCode

2329

self.processingHeaderObj.nCode = self.dataOut.nCode

2341

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2330

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2342

nCodeSize = 4 # bytes

2331

nCodeSize = 4 # bytes

2343

nBaudSize = 4 # bytes

2332

nBaudSize = 4 # bytes

2344

codeSize = 4 # bytes

2333

codeSize = 4 # bytes

2345

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

2334

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

2346

processingHeaderSize += sizeOfCode

2335

processingHeaderSize += sizeOfCode

2347

2336

2348

if self.processingHeaderObj.nWindows != 0:

2337

if self.processingHeaderObj.nWindows != 0:

2349

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

2338

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

2350

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

2339

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

2351

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2340

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2352

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2341

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2353

sizeOfFirstHeight = 4

2342

sizeOfFirstHeight = 4

2354

sizeOfdeltaHeight = 4

2343

sizeOfdeltaHeight = 4

2355

sizeOfnHeights = 4

2344

sizeOfnHeights = 4

2356

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

2345

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

2357

processingHeaderSize += sizeOfWindows

2346

processingHeaderSize += sizeOfWindows

2358

2347

2359

self.processingHeaderObj.size = processingHeaderSize

2348

self.processingHeaderObj.size = processingHeaderSize

2360

2349

2361

class SpectraHeisWriter():

2350

class SpectraHeisWriter():

2362

2351

2363

i=0

2352

i=0

2364

2353

2365

def __init__(self, dataOut):

2354

def __init__(self, dataOut):

2366

2355

2367

self.wrObj = FITS()

2356

self.wrObj = FITS()

2368

self.dataOut = dataOut

2357

self.dataOut = dataOut

2369

2358

2370

def isNumber(str):

2359

def isNumber(str):

2371

"""

2360

"""

2372

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.

2373

2362

2374

Excepciones:

2363

Excepciones:

2375

Si un determinado string no puede ser convertido a numero

2364

Si un determinado string no puede ser convertido a numero

2376

Input:

2365

Input:

2377

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

2378

2367

2379

Return:

2368

Return:

2380

True : si el string es uno numerico

2369

True : si el string es uno numerico

2381

False : no es un string numerico

2370

False : no es un string numerico

2382

"""

2371

"""

2383

try:

2372

try:

2384

float( str )

2373

float( str )

2385

return True

2374

return True

2386

except:

2375

except:

2387

return False

2376

return False

2388

2377

2389

def setup(self, wrpath,):

2378

def setup(self, wrpath,):

2390

2379

2391

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

2380

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

2392

os.mkdir(wrpath)

2381

os.mkdir(wrpath)

2393

2382

2394

self.wrpath = wrpath

2383

self.wrpath = wrpath

2395

self.setFile = 0

2384

self.setFile = 0

2396

2385

2397

def putData(self):

2386

def putData(self):

2398

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

2387

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

2399

#name = self.dataOut.utctime

2388

#name = self.dataOut.utctime

2400

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

2389

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

2401

ext=".fits"

2390

ext=".fits"

2402

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

2403

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)

2404

2393

2405

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

2394

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

2406

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

2395

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

2407

os.mkdir(doypath)

2396

os.mkdir(doypath)

2408

self.setFile += 1

2397

self.setFile += 1

2409

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)

2410

2399

2411

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

2400

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

2412

2401

2413

# print self.dataOut.ippSeconds

2402

# print self.dataOut.ippSeconds

2414

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)

2415

2404

2416

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)

2417

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

2418

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

2419

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

2420

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

2421

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

2422

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

2423

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

2424

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

2425

#n=numpy.arange((100))

2414

#n=numpy.arange((100))

2426

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

2415

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

2427

a=self.wrObj.cFImage(n)

2416

a=self.wrObj.cFImage(n)

2428

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)

2429

self.wrObj.CFile(a,b)

2418

self.wrObj.CFile(a,b)

2430

self.wrObj.wFile(filename)

2419

self.wrObj.wFile(filename)

2431

return 1

2420

return 1

2432

2421

2433

class FITS:

2422

class FITS:

2434

2423

2435

name=None

2424

name=None

2436

format=None

2425

format=None

2437

array =None

2426

array =None

2438

data =None

2427

data =None

2439

thdulist=None

2428

thdulist=None

2440

2429

2441

def __init__(self):

2430

def __init__(self):

2442

2431

2443

pass

2432

pass

2444

2433

2445

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

2434

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

2446

self.name=name

2435

self.name=name

2447

self.format=format

2436

self.format=format

2448

self.array=array

2437

self.array=array

2449

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

2438

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

2450

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)

2451

return self.col1

2440

return self.col1

2452

2441

2453

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

2442

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

2454

# self.name=name

2443

# self.name=name

2455

# self.format=format

2444

# self.format=format

2456

# self.data=data

2445

# self.data=data

2457

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

2446

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

2458

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

2459

# return self.col2

2448

# return self.col2

2460

2449

2461

def writeHeader(self,):

2450

def writeHeader(self,):

2462

pass

2451

pass

2463

2452

2464

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

2453

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

2465

self.name=name

2454

self.name=name

2466

self.format=format

2455

self.format=format

2467

self.data=data

2456

self.data=data

2468

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

2457

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

2469

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)

2470

return self.col2

2459

return self.col2

2471

2460

2472

def cFImage(self,n):

2461

def cFImage(self,n):

2473

self.hdu= pyfits.PrimaryHDU(n)

2462

self.hdu= pyfits.PrimaryHDU(n)

2474

return self.hdu

2463

return self.hdu

2475

2464

2476

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

2477

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

2478

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

2467

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

2479

return self.tbhdu

2468

return self.tbhdu

2480

2469

2481

def CFile(self,hdu,tbhdu):

2470

def CFile(self,hdu,tbhdu):

2482

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

2471

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

2483

2472

2484

def wFile(self,filename):

2473

def wFile(self,filename):

2485

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