schain Commit - r340:967f28151148 · Jicamarca Repository

Modificaciones para escribir datos en formato FITS

Daniel Valdez -

r340:967f28151148

parent child

Context file:

r340:967f28151148

Collapse all files

schainpy/model/jrodataIO.py +107 -51

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

schainpy/model/jroprocessing.py +6 -1

              '''
              $Author: dsuarez $
              $Id: Processor.py 1 2012-11-12 18:56:07Z dsuarez $
              '''
              import os
              import numpy
              import datetime
              import time
              from jrodata import *
              from jrodataIO import *
              from jroplot import *
              try:
                  import cfunctions
              except:
                  pass
              class ProcessingUnit:
                  """
                  Esta es la clase base para el procesamiento de datos.
                  Contiene el metodo "call" para llamar operaciones. Las operaciones pueden ser:
                      - Metodos internos (callMethod)
                      - Objetos del tipo Operation (callObject). Antes de ser llamados, estos objetos
                        tienen que ser agreagados con el metodo "add".
                  """
                  # objeto de datos de entrada (Voltage, Spectra o Correlation)
                  dataIn = None
                  # objeto de datos de entrada (Voltage, Spectra o Correlation)
                  dataOut = None
                  objectDict = None
                  def __init__(self):
                      self.objectDict = {}
                  def init(self):
                      raise ValueError, "Not implemented"
                  def addOperation(self, object, objId):
                      """
                      Agrega el objeto "object" a la lista de objetos "self.objectList" y retorna el
                      identificador asociado a este objeto.
                      Input:
                          object    :    objeto de la clase "Operation"
                      Return:
                          objId    :    identificador del objeto, necesario para ejecutar la operacion
                      """
                      self.objectDict[objId] = object
                      return objId
                  def operation(self, **kwargs):
                      """
                      Operacion directa sobre la data (dataOut.data). Es necesario actualizar los valores de los
                      atributos del objeto dataOut
                      Input:
                          **kwargs    :    Diccionario de argumentos de la funcion a ejecutar
                      """
                      raise ValueError, "ImplementedError"
                  def callMethod(self, name, **kwargs):
                      """
                      Ejecuta el metodo con el nombre "name" y con argumentos **kwargs de la propia clase.
                      Input:
                          name        :    nombre del metodo a ejecutar
                          **kwargs     :    diccionario con los nombres y valores de la funcion a ejecutar.
                      """
                      if name != 'run':
                          if name == 'init' and self.dataIn.isEmpty():
                              self.dataOut.flagNoData = True
                              return False
                          if name != 'init' and self.dataOut.isEmpty():
                              return False
                      methodToCall = getattr(self, name)
                      methodToCall(**kwargs)
                      if name != 'run':
                          return True
                      if self.dataOut.isEmpty():
                          return False
                      return True
                  def callObject(self, objId, **kwargs):
                      """
                      Ejecuta la operacion asociada al identificador del objeto "objId"
                      Input:
                          objId        :    identificador del objeto a ejecutar
                          **kwargs    :    diccionario con los nombres y valores de la funcion a ejecutar.
                      Return:
                          None
                      """
                      if self.dataOut.isEmpty():
                          return False
                      object = self.objectDict[objId]
                      object.run(self.dataOut, **kwargs)
                      return True
                  def call(self, operationConf, **kwargs):
                      """
                      Return True si ejecuta la operacion "operationConf.name" con los
                      argumentos "**kwargs". False si la operacion no se ha ejecutado.
                      La operacion puede ser de dos tipos:
 . Un metodo propio de esta clase:
                              operation.type = "self"
 . El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
                              operation.type = "other".
                             Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
                             "addOperation" e identificado con el operation.id
                      con el id de la operacion.
                      Input:
                          Operation    :    Objeto del tipo operacion con los atributos: name, type y id.
                      """
                      if operationConf.type == 'self':
                          sts = self.callMethod(operationConf.name, **kwargs)
                      if operationConf.type == 'other':
                          sts = self.callObject(operationConf.id, **kwargs)
                      return sts
                  def setInput(self, dataIn):
                      self.dataIn = dataIn
                  def getOutput(self):
                      return self.dataOut
              class Operation():
                  """
                  Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
                  y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
                  acumulacion dentro de esta clase
                  Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
                  """
                  __buffer = None
                  __isConfig = False
                  def __init__(self):
                      pass
                  def run(self, dataIn, **kwargs):
                      """
                      Realiza las operaciones necesarias sobre la dataIn.data y actualiza los atributos del objeto dataIn.
                      Input:
                          dataIn    :    objeto del tipo JROData
                      Return:
                          None
                      Affected:
                          __buffer    :    buffer de recepcion de datos.
                      """
                      raise ValueError, "ImplementedError"
              class VoltageProc(ProcessingUnit):
                  def __init__(self):
                      self.objectDict = {}
                      self.dataOut = Voltage()
                      self.flip = 1
                  def init(self):
                      self.dataOut.copy(self.dataIn)
                      # No necesita copiar en cada init() los atributos de dataIn
                      # la copia deberia hacerse por cada nuevo bloque de datos
                  def selectChannels(self, channelList):
                      channelIndexList = []
                      for channel in channelList:
                          index = self.dataOut.channelList.index(channel)
                          channelIndexList.append(index)
                      self.selectChannelsByIndex(channelIndexList)
                  def selectChannelsByIndex(self, channelIndexList):
                      """
                      Selecciona un bloque de datos en base a canales segun el channelIndexList
                      Input:
                          channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                      Affected:
                          self.dataOut.data
                          self.dataOut.channelIndexList
                          self.dataOut.nChannels
                          self.dataOut.m_ProcessingHeader.totalSpectra
                          self.dataOut.systemHeaderObj.numChannels
                          self.dataOut.m_ProcessingHeader.blockSize
                      Return:
                          None
                      """
                      for channelIndex in channelIndexList:
                          if channelIndex not in self.dataOut.channelIndexList:
                              print channelIndexList
                              raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
                      nChannels = len(channelIndexList)
                      data = self.dataOut.data[channelIndexList,:]
                      self.dataOut.data = data
                      self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
              #        self.dataOut.nChannels = nChannels
                      return 1
                  def selectHeights(self, minHei, maxHei):
                      """
                      Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                      minHei <= height <= maxHei
                      Input:
                          minHei    :    valor minimo de altura a considerar
                          maxHei    :    valor maximo de altura a considerar
                      Affected:
                          Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                      Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                      """
                      if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
                          raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                      if (maxHei > self.dataOut.heightList[-1]):
                          maxHei = self.dataOut.heightList[-1]
              #            raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                      minIndex = 0
                      maxIndex = 0
                      heights = self.dataOut.heightList
                      inda = numpy.where(heights >= minHei)
                      indb = numpy.where(heights <= maxHei)
                      try:
                          minIndex = inda[0][0]
                      except:
                          minIndex = 0
                      try:
                          maxIndex = indb[0][-1]
                      except:
                          maxIndex = len(heights)
                      self.selectHeightsByIndex(minIndex, maxIndex)
                      return 1
                  def selectHeightsByIndex(self, minIndex, maxIndex):
                      """
                      Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                      minIndex <= index <= maxIndex
                      Input:
                          minIndex    :    valor de indice minimo de altura a considerar
                          maxIndex    :    valor de indice maximo de altura a considerar
                      Affected:
                          self.dataOut.data
                          self.dataOut.heightList
                      Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                      """
                      if (minIndex < 0) or (minIndex > maxIndex):
                          raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                      if (maxIndex >= self.dataOut.nHeights):
                          maxIndex = self.dataOut.nHeights-1
              #            raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                      nHeights = maxIndex - minIndex + 1
                      #voltage
                      data = self.dataOut.data[:,minIndex:maxIndex+1]
                      firstHeight = self.dataOut.heightList[minIndex]
                      self.dataOut.data = data
                      self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
                      return 1
                  def filterByHeights(self, window):
                      deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                      if window == None:
                          window = self.dataOut.radarControllerHeaderObj.txA / deltaHeight
                      newdelta = deltaHeight * window
                      r = self.dataOut.data.shape[1] % window
                      buffer = self.dataOut.data[:,0:self.dataOut.data.shape[1]-r]
                      buffer = buffer.reshape(self.dataOut.data.shape[0],self.dataOut.data.shape[1]/window,window)
                      buffer = numpy.sum(buffer,2)
                      self.dataOut.data = buffer
                      self.dataOut.heightList = numpy.arange(self.dataOut.heightList[0],newdelta*self.dataOut.nHeights/window-newdelta,newdelta)
                      self.dataOut.windowOfFilter = window
                  def deFlip(self):
                      self.dataOut.data *= self.flip
                      self.flip *= -1.
              class CohInt(Operation):
                  __isConfig = False
                  __profIndex = 0
                  __withOverapping  = False
                  __byTime = False
                  __initime = None
                  __lastdatatime = None
                  __integrationtime = None
                  __buffer = None
                  __dataReady = False
                  n = None
                  def __init__(self):
                      self.__isConfig = False
                  def setup(self, n=None, timeInterval=None, overlapping=False):
                      """
                      Set the parameters of the integration class.
                      Inputs:
                          n        :    Number of coherent integrations
                          timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                          overlapping    :
                      """
                      self.__initime = None
                      self.__lastdatatime = 0
                      self.__buffer = None
                      self.__dataReady = False
                      if n == None and timeInterval == None:
                          raise ValueError, "n or timeInterval should be specified ..."
                      if n != None:
                          self.n = n
                          self.__byTime = False
                      else:
                          self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                          self.n = 9999
                          self.__byTime = True
                      if overlapping:
                          self.__withOverapping = True
                          self.__buffer = None
                      else:
                          self.__withOverapping = False
                          self.__buffer = 0
                      self.__profIndex = 0
                  def putData(self, data):
                      """
                      Add a profile to the __buffer and increase in one the __profileIndex
                      """
                      if not self.__withOverapping:
                          self.__buffer += data.copy()
                          self.__profIndex += 1
                          return
                      #Overlapping data
                      nChannels, nHeis = data.shape
                      data = numpy.reshape(data, (1, nChannels, nHeis))
                      #If the buffer is empty then it takes the data value
                      if self.__buffer == None:
                          self.__buffer = data
                          self.__profIndex += 1
                          return
                      #If the buffer length is lower than n then stakcing the data value
                      if self.__profIndex < self.n:
                          self.__buffer = numpy.vstack((self.__buffer, data))
                          self.__profIndex += 1
                          return
                      #If the buffer length is equal to n then replacing the last buffer value with the data value
                      self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                      self.__buffer[self.n-1] = data
                      self.__profIndex = self.n
                      return
                  def pushData(self):
                      """
                      Return the sum of the last profiles and the profiles used in the sum.
                      Affected:
                      self.__profileIndex
                      """
                      if not self.__withOverapping:
                          data = self.__buffer
                          n = self.__profIndex
                          self.__buffer = 0
                          self.__profIndex = 0
                          return data, n
                      #Integration with Overlapping
                      data = numpy.sum(self.__buffer, axis=0)
                      n = self.__profIndex
                      return data, n
                  def byProfiles(self, data):
                      self.__dataReady = False
                      avgdata = None
                      n = None
                      self.putData(data)
                      if self.__profIndex == self.n:
                          avgdata, n = self.pushData()
                          self.__dataReady = True
                      return avgdata
                  def byTime(self, data, datatime):
                      self.__dataReady = False
                      avgdata = None
                      n = None
                      self.putData(data)
                      if (datatime - self.__initime) >= self.__integrationtime:
                          avgdata, n = self.pushData()
                          self.n = n
                          self.__dataReady = True
                      return avgdata
                  def integrate(self, data, datatime=None):
                      if self.__initime == None:
                          self.__initime = datatime
                      if self.__byTime:
                          avgdata = self.byTime(data, datatime)
                      else:
                          avgdata = self.byProfiles(data)
                      self.__lastdatatime = datatime
                      if avgdata == None:
                          return None, None
                      avgdatatime = self.__initime
                      deltatime = datatime -self.__lastdatatime
                      if not self.__withOverapping:
                          self.__initime = datatime
                      else:
                          self.__initime += deltatime
                      return avgdata, avgdatatime
                  def run(self, dataOut, **kwargs):
                      if not self.__isConfig:
                          self.setup(**kwargs)
                          self.__isConfig = True
                      avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
              #        dataOut.timeInterval *= n
                      dataOut.flagNoData = True
                      if self.__dataReady:
                          dataOut.data = avgdata
                          dataOut.nCohInt *= self.n
                          dataOut.utctime = avgdatatime
                          dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
                          dataOut.flagNoData = False
              class Decoder(Operation):
                  __isConfig = False
                  __profIndex = 0
                  code = None
                  nCode = None
                  nBaud = None
                  def __init__(self):
                      self.__isConfig = False
                  def setup(self, code, shape):
                      self.__profIndex = 0
                      self.code = code
                      self.nCode = len(code)
                      self.nBaud = len(code[0])
                      self.__nChannels, self.__nHeis = shape
                      __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
                      __codeBuffer[:,0:self.nBaud] = self.code
                      self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
                      self.ndatadec = self.__nHeis - self.nBaud + 1
                      self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
                  def convolutionInFreq(self, data):
                      fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
                      fft_data = numpy.fft.fft(data, axis=1)
                      conv = fft_data*fft_code
                      data = numpy.fft.ifft(conv,axis=1)
                      datadec = data[:,:-self.nBaud+1]
                      return datadec
                  def convolutionInFreqOpt(self, data):
                      fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
                      data = cfunctions.decoder(fft_code, data)
                      datadec = data[:,:-self.nBaud+1]
                      return datadec
                  def convolutionInTime(self, data):
                      code = self.code[self.__profIndex]
                      for i in range(self.__nChannels):
                          self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='valid')
                      return self.datadecTime
                  def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0):
                      if not self.__isConfig:
                          if code == None:
                              code = dataOut.code
                          else:
                              code = numpy.array(code).reshape(nCode,nBaud)
                              dataOut.code = code
                              dataOut.nCode = nCode
                              dataOut.nBaud = nBaud
                          if code == None:
                              return 1
                          self.setup(code, dataOut.data.shape)
                          self.__isConfig = True
                      if mode == 0:
                          datadec = self.convolutionInTime(dataOut.data)
                      if mode == 1:
                          datadec = self.convolutionInFreq(dataOut.data)
                      if mode == 2:
                          datadec = self.convolutionInFreqOpt(dataOut.data)
                      dataOut.data = datadec
                      dataOut.heightList = dataOut.heightList[0:self.ndatadec]
                      dataOut.flagDecodeData = True #asumo q la data no esta decodificada
                      if self.__profIndex == self.nCode-1:
                          self.__profIndex = 0
                          return 1
                      self.__profIndex += 1
                      return 1
              #        dataOut.flagDeflipData = True #asumo q la data no esta sin flip
              class SpectraProc(ProcessingUnit):
                  def __init__(self):
                      self.objectDict = {}
                      self.buffer = None
                      self.firstdatatime = None
                      self.profIndex = 0
                      self.dataOut = Spectra()
                  def __updateObjFromInput(self):
                      self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                      self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                      self.dataOut.channelList = self.dataIn.channelList
                      self.dataOut.heightList = self.dataIn.heightList
                      self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
              #        self.dataOut.nHeights = self.dataIn.nHeights
              #        self.dataOut.nChannels = self.dataIn.nChannels
                      self.dataOut.nBaud = self.dataIn.nBaud
                      self.dataOut.nCode = self.dataIn.nCode
                      self.dataOut.code = self.dataIn.code
                      self.dataOut.nProfiles = self.dataOut.nFFTPoints
              #        self.dataOut.channelIndexList = self.dataIn.channelIndexList
                      self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
                      self.dataOut.utctime = self.firstdatatime
                      self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
                      self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
                      self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
                      self.dataOut.nCohInt = self.dataIn.nCohInt
                      self.dataOut.nIncohInt = 1
                      self.dataOut.ippSeconds = self.dataIn.ippSeconds
                      self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
                      self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
                  def __getFft(self):
                      """
                      Convierte valores de Voltaje a Spectra
                      Affected:
                          self.dataOut.data_spc
                          self.dataOut.data_cspc
                          self.dataOut.data_dc
                          self.dataOut.heightList
                          self.profIndex
                          self.buffer
                          self.dataOut.flagNoData
                      """
                      fft_volt = numpy.fft.fft(self.buffer,axis=1)
                      fft_volt = fft_volt.astype(numpy.dtype('complex'))
                      dc = fft_volt[:,0,:]
                      #calculo de self-spectra
                      fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                      spc = fft_volt * numpy.conjugate(fft_volt)
                      spc = spc.real
                      blocksize = 0
                      blocksize += dc.size
                      blocksize += spc.size
                      cspc = None
                      pairIndex = 0
                      if self.dataOut.pairsList != None:
                          #calculo de cross-spectra
                          cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                          for pair in self.dataOut.pairsList:
                              cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
                              pairIndex += 1
                          blocksize += cspc.size
                      self.dataOut.data_spc = spc
                      self.dataOut.data_cspc = cspc
                      self.dataOut.data_dc = dc
                      self.dataOut.blockSize = blocksize
                  def init(self, nFFTPoints=None, pairsList=None):
                      self.dataOut.flagNoData = True
                      if self.dataIn.type == "Spectra":
                          self.dataOut.copy(self.dataIn)
                          return
                      if self.dataIn.type == "Voltage":
                          if nFFTPoints == None:
                              raise ValueError, "This SpectraProc.init() need nFFTPoints input variable"
                          if pairsList == None:
                              nPairs = 0
                          else:
                              nPairs = len(pairsList)
                          self.dataOut.nFFTPoints = nFFTPoints
                          self.dataOut.pairsList = pairsList
                          self.dataOut.nPairs = nPairs
                          if self.buffer == None:
                              self.buffer = numpy.zeros((self.dataIn.nChannels,
                                                         self.dataOut.nFFTPoints,
                                                         self.dataIn.nHeights),
                                                         dtype='complex')
                          self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
                          self.profIndex += 1
                          if self.firstdatatime == None:
                              self.firstdatatime = self.dataIn.utctime
                          if self.profIndex == self.dataOut.nFFTPoints:
                              self.__updateObjFromInput()
                              self.__getFft()
                              self.dataOut.flagNoData = False
                              self.buffer = None
                              self.firstdatatime = None
                              self.profIndex = 0
                          return
                      raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
                  def selectChannels(self, channelList):
                      channelIndexList = []
                      for channel in channelList:
                          index = self.dataOut.channelList.index(channel)
                          channelIndexList.append(index)
                      self.selectChannelsByIndex(channelIndexList)
                  def selectChannelsByIndex(self, channelIndexList):
                      """
                      Selecciona un bloque de datos en base a canales segun el channelIndexList
                      Input:
                          channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                      Affected:
                          self.dataOut.data_spc
                          self.dataOut.channelIndexList
                          self.dataOut.nChannels
                      Return:
                          None
                      """
                      for channelIndex in channelIndexList:
                          if channelIndex not in self.dataOut.channelIndexList:
                              print channelIndexList
                              raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
                      nChannels = len(channelIndexList)
                      data_spc = self.dataOut.data_spc[channelIndexList,:]
                      self.dataOut.data_spc = data_spc
                      self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
              #        self.dataOut.nChannels = nChannels
                      return 1
                  def selectHeights(self, minHei, maxHei):
                      """
                      Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                      minHei <= height <= maxHei
                      Input:
                          minHei    :    valor minimo de altura a considerar
                          maxHei    :    valor maximo de altura a considerar
                      Affected:
                          Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                      Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                      """
                      if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
                          raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                      if (maxHei > self.dataOut.heightList[-1]):
                          maxHei = self.dataOut.heightList[-1]
              #            raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                      minIndex = 0
                      maxIndex = 0
                      heights = self.dataOut.heightList
                      inda = numpy.where(heights >= minHei)
                      indb = numpy.where(heights <= maxHei)
                      try:
                          minIndex = inda[0][0]
                      except:
                          minIndex = 0
                      try:
                          maxIndex = indb[0][-1]
                      except:
                          maxIndex = len(heights)
                      self.selectHeightsByIndex(minIndex, maxIndex)
                      return 1
                  def selectHeightsByIndex(self, minIndex, maxIndex):
                      """
                      Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                      minIndex <= index <= maxIndex
                      Input:
                          minIndex    :    valor de indice minimo de altura a considerar
                          maxIndex    :    valor de indice maximo de altura a considerar
                      Affected:
                          self.dataOut.data_spc
                          self.dataOut.data_cspc
                          self.dataOut.data_dc
                          self.dataOut.heightList
                      Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                      """
                      if (minIndex < 0) or (minIndex > maxIndex):
                          raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                      if (maxIndex >= self.dataOut.nHeights):
                          maxIndex = self.dataOut.nHeights-1
              #            raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                      nHeights = maxIndex - minIndex + 1
                      #Spectra
                      data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
                      data_cspc = None
                      if self.dataOut.data_cspc != None:
                          data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
                      data_dc = None
                      if self.dataOut.data_dc != None:
                          data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
                      self.dataOut.data_spc = data_spc
                      self.dataOut.data_cspc = data_cspc
                      self.dataOut.data_dc = data_dc
                      self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
                      return 1
                  def removeDC(self, mode = 1):
                      dc_index = 0
                      freq_index = numpy.array([-2,-1,1,2])
                      data_spc = self.dataOut.data_spc
                      data_cspc = self.dataOut.data_cspc
                      data_dc = self.dataOut.data_dc
                      if self.dataOut.flagShiftFFT:
                          dc_index += self.dataOut.nFFTPoints/2
                          freq_index += self.dataOut.nFFTPoints/2
                      if mode == 1:
                          data_spc[dc_index] = (data_spc[:,freq_index[1],:] + data_spc[:,freq_index[2],:])/2
                          if data_cspc != None:
                              data_cspc[dc_index] = (data_cspc[:,freq_index[1],:] + data_cspc[:,freq_index[2],:])/2
                          return 1
                      if mode == 2:
                          pass
                      if mode == 3:
                          pass
                      raise ValueError, "mode parameter has to be 1, 2 or 3"
                  def removeInterference(self):
                      pass
              class IncohInt(Operation):
                  __profIndex = 0
                  __withOverapping  = False
                  __byTime = False
                  __initime = None
                  __lastdatatime = None
                  __integrationtime = None
                  __buffer_spc = None
                  __buffer_cspc = None
                  __buffer_dc = None
                  __dataReady = False
                  __timeInterval = None
                  n = None
                  def __init__(self):
                      self.__isConfig = False
                  def setup(self, n=None, timeInterval=None, overlapping=False):
                      """
                      Set the parameters of the integration class.
                      Inputs:
                          n        :    Number of coherent integrations
                          timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                          overlapping    :
                      """
                      self.__initime = None
                      self.__lastdatatime = 0
                      self.__buffer_spc = None
                      self.__buffer_cspc = None
                      self.__buffer_dc = None
                      self.__dataReady = False
                      if n == None and timeInterval == None:
                          raise ValueError, "n or timeInterval should be specified ..."
                      if n != None:
                          self.n = n
                          self.__byTime = False
                      else:
                          self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                          self.n = 9999
                          self.__byTime = True
                      if overlapping:
                          self.__withOverapping = True
                      else:
                          self.__withOverapping = False
                          self.__buffer_spc = 0
                          self.__buffer_cspc = 0
                          self.__buffer_dc = 0
                      self.__profIndex = 0
                  def putData(self, data_spc, data_cspc, data_dc):
                      """
                      Add a profile to the __buffer_spc and increase in one the __profileIndex
                      """
                      if not self.__withOverapping:
                          self.__buffer_spc += data_spc
                          if data_cspc == None:
                              self.__buffer_cspc = None
                          else:
                              self.__buffer_cspc += data_cspc
                          if data_dc == None:
                              self.__buffer_dc = None
                          else:
                              self.__buffer_dc += data_dc
                          self.__profIndex += 1
                          return
                      #Overlapping data
                      nChannels, nFFTPoints, nHeis = data_spc.shape
                      data_spc = numpy.reshape(data_spc, (1, nChannels, nFFTPoints, nHeis))
                      if data_cspc != None:
                          data_cspc = numpy.reshape(data_cspc, (1, -1, nFFTPoints, nHeis))
                      if data_dc != None:
                          data_dc = numpy.reshape(data_dc, (1, -1, nHeis))
                      #If the buffer is empty then it takes the data value
                      if self.__buffer_spc == None:
                          self.__buffer_spc = data_spc
                          if data_cspc == None:
                              self.__buffer_cspc = None
                          else:
                              self.__buffer_cspc += data_cspc
                          if data_dc == None:
                              self.__buffer_dc = None
                          else:
                              self.__buffer_dc += data_dc
                          self.__profIndex += 1
                          return
                      #If the buffer length is lower than n then stakcing the data value
                      if self.__profIndex < self.n:
                          self.__buffer_spc = numpy.vstack((self.__buffer_spc, data_spc))
                          if data_cspc != None:
                              self.__buffer_cspc = numpy.vstack((self.__buffer_cspc, data_cspc))
                          if data_dc != None:
                              self.__buffer_dc = numpy.vstack((self.__buffer_dc, data_dc))
                          self.__profIndex += 1
                          return
                      #If the buffer length is equal to n then replacing the last buffer value with the data value
                      self.__buffer_spc = numpy.roll(self.__buffer_spc, -1, axis=0)
                      self.__buffer_spc[self.n-1] = data_spc
                      if data_cspc != None:
                          self.__buffer_cspc = numpy.roll(self.__buffer_cspc, -1, axis=0)
                          self.__buffer_cspc[self.n-1] = data_cspc
                      if data_dc != None:
                          self.__buffer_dc = numpy.roll(self.__buffer_dc, -1, axis=0)
                          self.__buffer_dc[self.n-1] = data_dc
                      self.__profIndex = self.n
                      return
                  def pushData(self):
                      """
                      Return the sum of the last profiles and the profiles used in the sum.
                      Affected:
                      self.__profileIndex
                      """
                      data_spc = None
                      data_cspc  = None
                      data_dc = None
                      if not self.__withOverapping:
                          data_spc = self.__buffer_spc
                          data_cspc = self.__buffer_cspc
                          data_dc = self.__buffer_dc
                          n = self.__profIndex
                          self.__buffer_spc = 0
                          self.__buffer_cspc = 0
                          self.__buffer_dc = 0
                          self.__profIndex = 0
                          return data_spc, data_cspc, data_dc, n
                      #Integration with Overlapping
                      data_spc = numpy.sum(self.__buffer_spc, axis=0)
                      if self.__buffer_cspc != None:
                          data_cspc = numpy.sum(self.__buffer_cspc, axis=0)
                      if self.__buffer_dc != None:
                          data_dc = numpy.sum(self.__buffer_dc, axis=0)
                      n = self.__profIndex
                      return data_spc, data_cspc, data_dc, n
                  def byProfiles(self, *args):
                      self.__dataReady = False
                      avgdata_spc = None
                      avgdata_cspc = None
                      avgdata_dc = None
                      n = None
                      self.putData(*args)
                      if self.__profIndex == self.n:
                          avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                          self.__dataReady = True
                      return avgdata_spc, avgdata_cspc, avgdata_dc
                  def byTime(self, datatime, *args):
                      self.__dataReady = False
                      avgdata_spc = None
                      avgdata_cspc = None
                      avgdata_dc = None
                      n = None
                      self.putData(*args)
                      if (datatime - self.__initime) >= self.__integrationtime:
                          avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                          self.n = n
                          self.__dataReady = True
                      return avgdata_spc, avgdata_cspc, avgdata_dc
                  def integrate(self, datatime, *args):
                      if self.__initime == None:
                          self.__initime = datatime
                      if self.__byTime:
                          avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
                      else:
                          avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
                      self.__lastdatatime = datatime
                      if avgdata_spc == None:
                          return None, None, None, None
                      avgdatatime = self.__initime
                      self.__timeInterval = (self.__lastdatatime - self.__initime)/(self.n - 1)
                      deltatime = datatime -self.__lastdatatime
                      if not self.__withOverapping:
                          self.__initime = datatime
                      else:
                          self.__initime += deltatime
                      return avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc
                  def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
                      if n==1:
                          dataOut.flagNoData = False
                          return
                      if not self.__isConfig:
                          self.setup(n, timeInterval, overlapping)
                          self.__isConfig = True
                      avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
                                                                                          dataOut.data_spc,
                                                                                          dataOut.data_cspc,
                                                                                          dataOut.data_dc)
              #        dataOut.timeInterval *= n
                      dataOut.flagNoData = True
                      if self.__dataReady:
                          dataOut.data_spc = avgdata_spc
                          dataOut.data_cspc = avgdata_cspc
                          dataOut.data_dc = avgdata_dc
                          dataOut.nIncohInt *= self.n
                          dataOut.utctime = avgdatatime
                          #dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints
                          dataOut.timeInterval = self.__timeInterval*self.n
                          dataOut.flagNoData = False
              class ProfileSelector(Operation):
                  profileIndex = None
                  # Tamanho total de los perfiles
                  nProfiles = None
                  def __init__(self):
                      self.profileIndex = 0
                  def incIndex(self):
                      self.profileIndex += 1
                      if self.profileIndex >= self.nProfiles:
                          self.profileIndex = 0
                  def isProfileInRange(self, minIndex, maxIndex):
                      if self.profileIndex < minIndex:
                          return False
                      if self.profileIndex > maxIndex:
                          return False
                      return True
                  def isProfileInList(self, profileList):
                      if self.profileIndex not in profileList:
                          return False
                      return True
                  def run(self, dataOut, profileList=None, profileRangeList=None):
                      dataOut.flagNoData = True
                      self.nProfiles = dataOut.nProfiles
                      if profileList != None:
                          if self.isProfileInList(profileList):
                              dataOut.flagNoData = False
                          self.incIndex()
                          return 1
                      elif profileRangeList != None:
                          minIndex = profileRangeList[0]
                          maxIndex = profileRangeList[1]
                          if self.isProfileInRange(minIndex, maxIndex):
                              dataOut.flagNoData = False
                          self.incIndex()
                          return 1
                      else:
                          raise ValueError, "ProfileSelector needs profileList or profileRangeList"
                      return 0
              class SpectraHeisProc(ProcessingUnit):
                  def __init__(self):
                      self.objectDict = {}
              #        self.buffer = None
              #        self.firstdatatime = None
              #        self.profIndex = 0
                      self.dataOut = SpectraHeis()
                  def __updateObjFromInput(self):
                      self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()#
                      self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()#
                      self.dataOut.channelList = self.dataIn.channelList
                      self.dataOut.heightList = self.dataIn.heightList
              #        self.dataOut.dtype = self.dataIn.dtype
                      self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
              #        self.dataOut.nHeights = self.dataIn.nHeights
              #        self.dataOut.nChannels = self.dataIn.nChannels
                      self.dataOut.nBaud = self.dataIn.nBaud
                      self.dataOut.nCode = self.dataIn.nCode
                      self.dataOut.code = self.dataIn.code
              #        self.dataOut.nProfiles = 1
              #        self.dataOut.nProfiles = self.dataOut.nFFTPoints
                      self.dataOut.nFFTPoints = self.dataIn.nHeights
              #        self.dataOut.channelIndexList = self.dataIn.channelIndexList
              #        self.dataOut.flagNoData = self.dataIn.flagNoData
                      self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
                      self.dataOut.utctime = self.dataIn.utctime
              #        self.dataOut.utctime = self.firstdatatime
                      self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
                      self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
                      self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
                      self.dataOut.nCohInt = self.dataIn.nCohInt
                      self.dataOut.nIncohInt = 1
                      self.dataOut.ippSeconds= self.dataIn.ippSeconds
                      self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
                      self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nIncohInt
              #        self.dataOut.set=self.dataIn.set
              #        self.dataOut.deltaHeight=self.dataIn.deltaHeight
                  def __getFft(self):
                      fft_volt = numpy.fft.fft(self.dataIn.data, axis=1)
                      fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                      spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))/(self.dataOut.nFFTPoints)
                      self.dataOut.data_spc = spc
                  def init(self):
                      self.dataOut.flagNoData = True
                      if self.dataIn.type == "SpectraHeis":
                          self.dataOut.copy(self.dataIn)
                          return
                      if self.dataIn.type == "Voltage":
                          self.__updateObjFromInput()
                          self.__getFft()
                          self.dataOut.flagNoData = False
                          return
                      raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
                  def selectChannels(self, channelList):
                      channelIndexList = []
                      for channel in channelList:
                          index = self.dataOut.channelList.index(channel)
                          channelIndexList.append(index)
                      self.selectChannelsByIndex(channelIndexList)
                  def selectChannelsByIndex(self, channelIndexList):
                      """
                      Selecciona un bloque de datos en base a canales segun el channelIndexList
                      Input:
                          channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                      Affected:
                          self.dataOut.data
                          self.dataOut.channelIndexList
                          self.dataOut.nChannels
                          self.dataOut.m_ProcessingHeader.totalSpectra
                          self.dataOut.systemHeaderObj.numChannels
                          self.dataOut.m_ProcessingHeader.blockSize
                      Return:
                          None
                      """
                      for channelIndex in channelIndexList:
                          if channelIndex not in self.dataOut.channelIndexList:
                              print channelIndexList
                              raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
                      nChannels = len(channelIndexList)
                      data_spc = self.dataOut.data_spc[channelIndexList,:]
                      self.dataOut.data_spc = data_spc
                      self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                      return 1
              class IncohInt4SpectraHeis(Operation):
                  __isConfig = False
                  __profIndex = 0
                  __withOverapping  = False
                  __byTime = False
                  __initime = None
                  __lastdatatime = None
                  __integrationtime = None
                  __buffer = None
                  __dataReady = False
                  n = None
                  def __init__(self):
                      self.__isConfig = False
                  def setup(self, n=None, timeInterval=None, overlapping=False):
                      """
                      Set the parameters of the integration class.
                      Inputs:
                          n        :    Number of coherent integrations
                          timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                          overlapping    :
                      """
                      self.__initime = None
                      self.__lastdatatime = 0
                      self.__buffer = None
                      self.__dataReady = False
                      if n == None and timeInterval == None:
                          raise ValueError, "n or timeInterval should be specified ..."
                      if n != None:
                          self.n = n
                          self.__byTime = False
                      else:
                          self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
                          self.n = 9999
                          self.__byTime = True
                      if overlapping:
                          self.__withOverapping = True
                          self.__buffer = None
                      else:
                          self.__withOverapping = False
                          self.__buffer = 0
                      self.__profIndex = 0
                  def putData(self, data):
                      """
                      Add a profile to the __buffer and increase in one the __profileIndex
                      """
                      if not self.__withOverapping:
                          self.__buffer += data.copy()
                          self.__profIndex += 1
                          return
                      #Overlapping data
                      nChannels, nHeis = data.shape
                      data = numpy.reshape(data, (1, nChannels, nHeis))
                      #If the buffer is empty then it takes the data value
                      if self.__buffer == None:
                          self.__buffer = data
                          self.__profIndex += 1
                          return
                      #If the buffer length is lower than n then stakcing the data value
                      if self.__profIndex < self.n:
                          self.__buffer = numpy.vstack((self.__buffer, data))
                          self.__profIndex += 1
                          return
                      #If the buffer length is equal to n then replacing the last buffer value with the data value
                      self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                      self.__buffer[self.n-1] = data
                      self.__profIndex = self.n
                      return
                  def pushData(self):
                      """
                      Return the sum of the last profiles and the profiles used in the sum.
                      Affected:
                      self.__profileIndex
                      """
                      if not self.__withOverapping:
                          data = self.__buffer
                          n = self.__profIndex
                          self.__buffer = 0
                          self.__profIndex = 0
                          return data, n
                      #Integration with Overlapping
                      data = numpy.sum(self.__buffer, axis=0)
                      n = self.__profIndex
                      return data, n
                  def byProfiles(self, data):
                      self.__dataReady = False
                      avgdata = None
                      n = None
                      self.putData(data)
                      if self.__profIndex == self.n:
                          avgdata, n = self.pushData()
                          self.__dataReady = True
                      return avgdata
                  def byTime(self, data, datatime):
                      self.__dataReady = False
                      avgdata = None
                      n = None
                      self.putData(data)
                      if (datatime - self.__initime) >= self.__integrationtime:
                          avgdata, n = self.pushData()
                          self.n = n
                          self.__dataReady = True
                      return avgdata
                  def integrate(self, data, datatime=None):
                      if self.__initime == None:
                          self.__initime = datatime
                      if self.__byTime:
                          avgdata = self.byTime(data, datatime)
                      else:
                          avgdata = self.byProfiles(data)
                      self.__lastdatatime = datatime
                      if avgdata == None:
                          return None, None
                      avgdatatime = self.__initime
                      deltatime = datatime -self.__lastdatatime
                      if not self.__withOverapping:
                          self.__initime = datatime
                      else:
                          self.__initime += deltatime
                      return avgdata, avgdatatime
                  def run(self, dataOut, **kwargs):
                      if not self.__isConfig:
                          self.setup(**kwargs)
                          self.__isConfig = True
                      avgdata, avgdatatime = self.integrate(dataOut.data_spc, dataOut.utctime)
              #        dataOut.timeInterval *= n
                      dataOut.flagNoData = True
                      if self.__dataReady:
                          dataOut.data_spc = avgdata
                          dataOut.nIncohInt *= self.n
              #            dataOut.nCohInt *= self.n
                          dataOut.utctime = avgdatatime
                          dataOut.timeInterval = dataOut.ippSeconds * dataOut.nIncohInt
              #            dataOut.timeInterval = self.__timeInterval*self.n
-                         dataOut.flagNoData = False
  No newline at end of file
+                         dataOut.flagNoData = False
+  No newline at end of file

schainpy/test/SunExperiment.py +4 0

              import os, sys
              path = os.path.split(os.getcwd())[0]
              sys.path.append(path)
              from controller import *
              desc = "Sun Experiment Test"
              filename = "sunexp.xml"
              controllerObj = Project()
              controllerObj.setup(id = '191', name='test01', description=desc)
              #/Users/dsuarez/Documents/RadarData/SunExperiment
              #/Volumes/data_e/PaseDelSol/Raw/100KHZ
              readUnitConfObj = controllerObj.addReadUnit(datatype='Voltage',
                                                          path='/Users/dsuarez/Documents/RadarData/SunExperiment',
                                                          startDate='2013/02/06',
                                                          endDate='2013/12/31',
                                                          startTime='00:30:00',
                                                          endTime='17:40:59',
                                                          online=0,
                                                          delay=3,
                                                          walk=1)
              procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage', inputId=readUnitConfObj.getId())
              procUnitConfObj1 = controllerObj.addProcUnit(datatype='SpectraHeis', inputId=procUnitConfObj0.getId())
              opObj11 = procUnitConfObj1.addOperation(name='IncohInt4SpectraHeis', optype='other')
              opObj11.addParameter(name='timeInterval', value='5', format='float')
              opObj11 = procUnitConfObj1.addOperation(name='SpectraHeisScope', optype='other')
              opObj11.addParameter(name='idfigure', value='10', format='int')
              opObj11.addParameter(name='wintitle', value='SpectraHeisPlot', format='str')
              #opObj11.addParameter(name='ymin', value='125', format='int')
              #opObj11.addParameter(name='ymax', value='140', format='int')
              #opObj11.addParameter(name='channelList', value='0,1,2', format='intlist')
              #opObj11.addParameter(name='showprofile', value='1', format='int')
              opObj11.addParameter(name='save', value='1', format='bool')
              opObj11.addParameter(name='figfile', value='spc-noise.png', format='str')
              opObj11.addParameter(name='figpath', value='/Users/dsuarez/Pictures/sun_pics', format='str')
              opObj11.addParameter(name='ftp', value='1', format='int')
              opObj11.addParameter(name='ftpratio', value='10', format='int')
              opObj11 = procUnitConfObj1.addOperation(name='RTIfromSpectraHeis', optype='other')
              opObj11.addParameter(name='idfigure', value='6', format='int')
              opObj11.addParameter(name='wintitle', value='RTIPLot', format='str')
              #opObj11.addParameter(name='zmin', value='10', format='int')
              #opObj11.addParameter(name='zmax', value='40', format='int')
              opObj11.addParameter(name='ymin', value='60', format='int')
              opObj11.addParameter(name='ymax', value='85', format='int')
              #opObj11.addParameter(name='channelList', value='0,1,2,3', format='intlist')
              #opObj11.addParameter(name='timerange', value='600', format='int')
              #opObj11.addParameter(name='showprofile', value='0', format='int')
              opObj11.addParameter(name='save', value='1', format='bool')
              opObj11.addParameter(name='figfile', value='rti-noise.png', format='str')
              opObj11.addParameter(name='figpath', value='/Users/dsuarez/Pictures/sun_pics', format='str')
              opObj11.addParameter(name='ftp', value='1', format='int')
              opObj11.addParameter(name='ftpratio', value='10', format='int')
+             opObj11 = procUnitConfObj1.addOperation(name='SpectraHeisWriter', optype='other')
+             opObj11.addParameter(name='wrpath', value='/Users/dsuarez/Remote', format='str')
+             #opObj11.addParameter(name='blocksPerFile', value='200', format='int')
              print "Escribiendo el archivo XML"
              controllerObj.writeXml(filename)
              print "Leyendo el archivo XML"
              controllerObj.readXml(filename)
              controllerObj.createObjects()
              controllerObj.connectObjects()
              controllerObj.run()
   No newline at end of file

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	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