schain-jc Commit - r457:2445b97595f3

             '''
             $Author: murco $
             $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
             '''
             import os, sys
             import copy
             import numpy
             import datetime
             from jroheaderIO import SystemHeader, RadarControllerHeader
             def hildebrand_sekhon(data, navg):
                 data = data.copy()
                 sortdata = numpy.sort(data,axis=None)
                 lenOfData = len(sortdata)
                 nums_min = lenOfData/10
                 if (lenOfData/10) > 2:
                     nums_min = lenOfData/10
                 else:
                     nums_min = 2
                 sump = 0.
                 sumq = 0.
                 j = 0
                 cont = 1
                 while((cont==1)and(j<lenOfData)):
                     sump += sortdata[j]
                     sumq += sortdata[j]**2
                     j += 1
                     if j > nums_min:
                         rtest = float(j)/(j-1) + 1.0/navg
                         if ((sumq*j) > (rtest*sump**2)):
                             j = j - 1
                             sump  = sump - sortdata[j]
                             sumq =  sumq - sortdata[j]**2
                             cont = 0
                 lnoise = sump /j
                 stdv = numpy.sqrt((sumq - lnoise**2)/(j - 1))
                 return lnoise
             class JROData:
             #    m_BasicHeader = BasicHeader()
             #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
             #    data = None
                 type = None
                 dtype = None
             #    nChannels = None
             #    nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagNoData = True
                 flagTimeBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
                 nCode = None
                 nBaud = None
                 code = None
                 flagDecodeData = False #asumo q la data no esta decodificada
                 flagDeflipData = False #asumo q la data no esta sin flip
                 flagShiftFFT = False
                 ippSeconds = None
                 timeInterval = None
                 nCohInt = None
                 noise = None
                 windowOfFilter = 1
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
+                last_block = None
+                blocknow = None
                 def __init__(self):
                     raise ValueError, "This class has not been implemented"
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in inputObj.__dict__.keys():
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
                 def isEmpty(self):
                     return self.flagNoData
                 def getNoise(self):
                     raise ValueError, "Not implemented"
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNHeights(self):
                     return len(self.heightList)
                 def getHeiRange(self, extrapoints=0):
                     heis = self.heightList
             #        deltah = self.heightList[1] - self.heightList[0]
             #
             #        heis.append(self.heightList[-1])
                     return heis
                 def getltctime(self):
                     if self.useLocalTime:
                          return self.utctime - self.timeZone*60
                     return self.utctime
                 def getDatatime(self):
                     datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatime
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getFmax(self):
                     PRF = 1./(self.ippSeconds * self.nCohInt)
                     fmax = PRF/2.
                     return fmax
                 def getVmax(self):
                     _lambda = self.C/self.frequency
                     vmax = self.getFmax() * _lambda
                     return vmax
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
             class Voltage(JROData):
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
                     self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagTimeBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = None
                     self.blocksize = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                 def getNoisebyHildebrand(self):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,:,:]
                         self.noise[channel] = hildebrand_sekhon(daux, self.nCohInt)
                     return self.noise
                 def getNoise(self, type = 1):
                     self.noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     return 10*numpy.log10(noise)
             class Spectra(JROData):
                 #data es un numpy array de 2 dmensiones (canales, perfiles, alturas)
                 data_spc = None
                 #data es un numpy array de 2 dmensiones (canales, pares, alturas)
                 data_cspc = None
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data_dc = None
                 nFFTPoints = None
                 nPairs = None
                 pairsList = None
                 nIncohInt = None
                 wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia
                 nCohInt = None #se requiere para determinar el valor de timeInterval
                 ippFactor = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
             #        self.data = None
                     self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagTimeBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.blocksize = None
                     self.nFFTPoints = None
                     self.wavelength = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.ippFactor = 1
                     self.noise = None
                     self.beacon_heiIndexList = []
                 def getNoisebyHildebrand(self):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     noise = numpy.zeros(self.nChannels)
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,:,:]
                         noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return noise
                 def getNoise(self):
                     if self.noise != None:
                         return self.noise
                     else:
                         noise = self.getNoisebyHildebrand()
                         return noise
                 def getFreqRange(self, extrapoints=0):
                     deltafreq = self.getFmax() / (self.nFFTPoints*self.ippFactor)
                     freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
                     return freqrange
                 def getVelRange(self, extrapoints=0):
                     deltav = self.getVmax() / (self.nFFTPoints*self.ippFactor)
                     velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltav/2
                     return velrange
                 def getNPairs(self):
                     return len(self.pairsList)
                 def getPairsIndexList(self):
                     return range(self.nPairs)
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode
                     return normFactor
                 def getFlagCspc(self):
                     if self.data_cspc == None:
                         return True
                     return False
                 def getFlagDc(self):
                     if self.data_dc == None:
                         return True
                     return False
                 nPairs = property(getNPairs, "I'm the 'nPairs' property.")
                 pairsIndexList = property(getPairsIndexList, "I'm the 'pairsIndexList' property.")
                 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
                 flag_cspc = property(getFlagCspc)
                 flag_dc = property(getFlagDc)
             class SpectraHeis(JROData):
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 nFFTPoints = None
                 nPairs = None
                 pairsList = None
                 nIncohInt = None
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
                     self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagTimeBlock = False
                     self.nPairs = 0
                     self.utctime = None
                     self.blocksize = None
             class Fits:
                 heightList = None
                 channelList = None
                 flagNoData = True
                 flagTimeBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 ippSeconds = None
                 timeInterval = None
                 nCohInt = None
                 nIncohInt = None
                 noise = None
                 windowOfFilter = 1
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #         self.channelIndexList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.useLocalTime = True
             #         self.utctime = None
             #         self.timeZone = None
             #         self.ltctime = None
             #         self.timeInterval = None
             #         self.header = None
             #         self.data_header = None
             #         self.data = None
             #         self.datatime = None
             #         self.flagNoData = False
             #         self.expName = ''
             #         self.nChannels = None
             #         self.nSamples = None
             #         self.dataBlocksPerFile = None
             #         self.comments = ''
             #
                 def getltctime(self):
                     if self.useLocalTime:
                          return self.utctime - self.timeZone*60
                     return self.utctime
                 def getDatatime(self):
                     datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatime
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getHeiRange(self):
                     heis = self.heightList
                     return heis
                 def isEmpty(self):
                     return self.flagNoData
                 def getNHeights(self):
                     return len(self.heightList)
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNoise(self, type = 1):
                     self.noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")

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

1

'''

1

'''

2

3

$Author: murco $

3

$Author: murco $

4

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

4

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

5

'''

5

'''

6

7

import os, sys

7

import os, sys

8

import glob

8

import glob

9

import time

9

import time

10

import numpy

10

import numpy

11

import fnmatch

11

import fnmatch

12

import time, datetime

12

import time, datetime

13

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

13

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

14

try:

14

try:

15

import pyfits

15

import pyfits

16

except:

16

except:

17

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

17

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

18

19

from jrodata import *

19

from jrodata import *

20

from jroheaderIO import *

20

from jroheaderIO import *

21

from jroprocessing import *

21

from jroprocessing import *

22

23

LOCALTIME = True #-18000

23

LOCALTIME = True #-18000

24

25

def isNumber(str):

25

def isNumber(str):

26

"""

26

"""

27

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

27

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

28

29

Excepciones:

29

Excepciones:

30

Si un determinado string no puede ser convertido a numero

30

Si un determinado string no puede ser convertido a numero

31

Input:

31

Input:

32

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

32

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

33

34

Return:

34

Return:

35

True : si el string es uno numerico

35

True : si el string es uno numerico

36

False : no es un string numerico

36

False : no es un string numerico

37

"""

37

"""

38

try:

38

try:

39

float( str )

39

float( str )

40

return True

40

return True

41

except:

41

except:

42

return False

42

return False

43

44

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

44

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

45

"""

45

"""

46

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

46

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

47

48

Inputs:

48

Inputs:

49

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

49

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

50

51

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

51

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

52

segundos contados desde 01/01/1970.

52

segundos contados desde 01/01/1970.

53

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

53

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

54

segundos contados desde 01/01/1970.

54

segundos contados desde 01/01/1970.

55

56

Return:

56

Return:

57

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

57

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

58

fecha especificado, de lo contrario retorna False.

58

fecha especificado, de lo contrario retorna False.

59

60

Excepciones:

60

Excepciones:

61

Si el archivo no existe o no puede ser abierto

61

Si el archivo no existe o no puede ser abierto

62

Si la cabecera no puede ser leida.

62

Si la cabecera no puede ser leida.

63

64

"""

64

"""

65

basicHeaderObj = BasicHeader(LOCALTIME)

65

basicHeaderObj = BasicHeader(LOCALTIME)

66

67

try:

67

try:

68

fp = open(filename,'rb')

68

fp = open(filename,'rb')

69

except:

69

except:

70

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

70

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

71

72

sts = basicHeaderObj.read(fp)

72

sts = basicHeaderObj.read(fp)

73

fp.close()

73

fp.close()

74

75

if not(sts):

75

if not(sts):

76

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

76

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

77

return 0

77

return 0

78

79

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

79

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

80

return 0

80

return 0

81

82

return 1

82

return 1

83

84

def isFileinThisTime(filename, startTime, endTime):

84

def isFileinThisTime(filename, startTime, endTime):

85

"""

85

"""

86

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

86

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

87

88

Inputs:

88

Inputs:

89

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

89

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

90

91

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

91

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

92

93

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

93

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

94

95

Return:

95

Return:

96

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

96

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

97

fecha especificado, de lo contrario retorna False.

97

fecha especificado, de lo contrario retorna False.

98

99

Excepciones:

99

Excepciones:

100

Si el archivo no existe o no puede ser abierto

100

Si el archivo no existe o no puede ser abierto

101

Si la cabecera no puede ser leida.

101

Si la cabecera no puede ser leida.

102

103

"""

103

"""

104

105

106

try:

106

try:

107

fp = open(filename,'rb')

107

fp = open(filename,'rb')

108

except:

108

except:

109

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

109

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

110

111

basicHeaderObj = BasicHeader(LOCALTIME)

111

basicHeaderObj = BasicHeader(LOCALTIME)

112

sts = basicHeaderObj.read(fp)

112

sts = basicHeaderObj.read(fp)

113

fp.close()

113

fp.close()

114

115

thisDatetime = basicHeaderObj.datatime

115

thisDatetime = basicHeaderObj.datatime

116

thisTime = basicHeaderObj.datatime.time()

116

thisTime = basicHeaderObj.datatime.time()

117

118

if not(sts):

118

if not(sts):

119

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

119

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

120

return None

120

return None

121

122

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

122

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

123

return None

123

return None

124

125

return thisDatetime

125

return thisDatetime

126

127

def getFileFromSet(path,ext,set):

127

def getFileFromSet(path,ext,set):

128

validFilelist = []

128

validFilelist = []

129

fileList = os.listdir(path)

129

fileList = os.listdir(path)

130

131

# 0 1234 567 89A BCDE

131

# 0 1234 567 89A BCDE

132

# H YYYY DDD SSS .ext

132

# H YYYY DDD SSS .ext

133

134

for file in fileList:

134

for file in fileList:

135

try:

135

try:

136

year = int(file[1:5])

136

year = int(file[1:5])

137

doy = int(file[5:8])

137

doy = int(file[5:8])

138

139

140

except:

140

except:

141

continue

141

continue

142

143

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

143

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

144

continue

144

continue

145

146

validFilelist.append(file)

146

validFilelist.append(file)

147

148

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

148

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

149

150

if len(myfile)!= 0:

150

if len(myfile)!= 0:

151

return myfile[0]

151

return myfile[0]

152

else:

152

else:

153

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

153

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

154

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

154

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

155

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

155

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

156

157

if validFilelist:

157

if validFilelist:

158

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

158

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

159

return validFilelist[-1]

159

return validFilelist[-1]

160

161

return None

161

return None

162

163

164

def getlastFileFromPath(path, ext):

164

def getlastFileFromPath(path, ext):

165

"""

165

"""

166

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

166

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

167

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

167

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

168

169

Input:

169

Input:

170

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

170

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

171

ext : extension de los files contenidos en una carpeta

171

ext : extension de los files contenidos en una carpeta

172

173

Return:

173

Return:

174

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

174

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

175

"""

175

"""

176

validFilelist = []

176

validFilelist = []

177

fileList = os.listdir(path)

177

fileList = os.listdir(path)

178

179

# 0 1234 567 89A BCDE

179

# 0 1234 567 89A BCDE

180

# H YYYY DDD SSS .ext

180

# H YYYY DDD SSS .ext

181

182

for file in fileList:

182

for file in fileList:

183

try:

183

try:

184

year = int(file[1:5])

184

year = int(file[1:5])

185

doy = int(file[5:8])

185

doy = int(file[5:8])

186

187

188

except:

188

except:

189

continue

189

continue

190

191

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

191

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

192

continue

192

continue

193

194

validFilelist.append(file)

194

validFilelist.append(file)

195

196

if validFilelist:

196

if validFilelist:

197

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

197

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

198

return validFilelist[-1]

198

return validFilelist[-1]

199

200

return None

200

return None

201

202

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

202

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

203

"""

203

"""

204

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

204

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

205

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

205

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

206

el path exacto de un determinado file.

206

el path exacto de un determinado file.

207

208

Example :

208

Example :

209

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

209

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

210

211

Entonces la funcion prueba con las siguientes combinaciones

211

Entonces la funcion prueba con las siguientes combinaciones

212

.../.../y2009307367.ext

212

.../.../y2009307367.ext

213

.../.../Y2009307367.ext

213

.../.../Y2009307367.ext

214

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

214

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

215

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

215

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

216

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

216

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

217

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

217

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

218

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

218

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

219

220

Return:

220

Return:

221

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

221

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

222

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

222

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

223

para el filename

223

para el filename

224

"""

224

"""

225

fullfilename = None

225

fullfilename = None

226

find_flag = False

226

find_flag = False

227

filename = None

227

filename = None

228

229

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

229

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

230

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

230

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

231

prefixFileList = ['d','D']

231

prefixFileList = ['d','D']

232

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

232

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

233

prefixFileList = ['p','P']

233

prefixFileList = ['p','P']

234

else:

234

else:

235

return None, filename

235

return None, filename

236

237

#barrido por las combinaciones posibles

237

#barrido por las combinaciones posibles

238

for prefixDir in prefixDirList:

238

for prefixDir in prefixDirList:

239

thispath = path

239

thispath = path

240

if prefixDir != None:

240

if prefixDir != None:

241

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

241

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

242

if foldercounter == 0:

242

if foldercounter == 0:

243

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

243

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

244

else:

244

else:

245

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

245

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

246

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

246

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

247

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

247

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

248

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

248

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

249

250

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

250

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

251

find_flag = True

251

find_flag = True

252

break

252

break

253

if find_flag:

253

if find_flag:

254

break

254

break

255

256

if not(find_flag):

256

if not(find_flag):

257

return None, filename

257

return None, filename

258

259

return fullfilename, filename

259

return fullfilename, filename

260

261

def isDoyFolder(folder):

261

def isDoyFolder(folder):

262

try:

262

try:

263

year = int(folder[1:5])

263

year = int(folder[1:5])

264

except:

264

except:

265

return 0

265

return 0

266

267

try:

267

try:

268

doy = int(folder[5:8])

268

doy = int(folder[5:8])

269

except:

269

except:

270

return 0

270

return 0

271

272

return 1

272

return 1

273

274

class JRODataIO:

274

class JRODataIO:

275

276

c = 3E8

276

c = 3E8

277

278

isConfig = False

278

isConfig = False

279

280

basicHeaderObj = BasicHeader(LOCALTIME)

280

basicHeaderObj = BasicHeader(LOCALTIME)

281

282

systemHeaderObj = SystemHeader()

282

systemHeaderObj = SystemHeader()

283

284

radarControllerHeaderObj = RadarControllerHeader()

284

radarControllerHeaderObj = RadarControllerHeader()

285

286

processingHeaderObj = ProcessingHeader()

286

processingHeaderObj = ProcessingHeader()

287

288

online = 0

288

online = 0

289

290

dtype = None

290

dtype = None

291

292

pathList = []

292

pathList = []

293

294

filenameList = []

294

filenameList = []

295

296

filename = None

296

filename = None

297

298

ext = None

298

ext = None

299

300

flagIsNewFile = 1

300

flagIsNewFile = 1

301

302

flagTimeBlock = 0

302

flagTimeBlock = 0

303

304

flagIsNewBlock = 0

304

flagIsNewBlock = 0

305

306

fp = None

306

fp = None

307

308

firstHeaderSize = 0

308

firstHeaderSize = 0

309

310

basicHeaderSize = 24

310

basicHeaderSize = 24

311

312

versionFile = 1103

312

versionFile = 1103

313

314

fileSize = None

314

fileSize = None

315

316

ippSeconds = None

316

ippSeconds = None

317

318

fileSizeByHeader = None

318

fileSizeByHeader = None

319

320

fileIndex = None

320

fileIndex = None

321

322

profileIndex = None

322

profileIndex = None

323

324

blockIndex = None

324

blockIndex = None

325

326

nTotalBlocks = None

326

nTotalBlocks = None

327

328

maxTimeStep = 30

328

maxTimeStep = 30

329

330

lastUTTime = None

330

lastUTTime = None

331

332

datablock = None

332

datablock = None

333

334

dataOut = None

334

dataOut = None

335

336

blocksize = None

336

blocksize = None

337

338

def __init__(self):

338

def __init__(self):

339

340

raise ValueError, "Not implemented"

340

raise ValueError, "Not implemented"

341

342

def run(self):

342

def run(self):

343

344

raise ValueError, "Not implemented"

344

raise ValueError, "Not implemented"

345

346

def getOutput(self):

346

def getOutput(self):

347

348

return self.dataOut

348

return self.dataOut

349

350

class JRODataReader(JRODataIO, ProcessingUnit):

350

class JRODataReader(JRODataIO, ProcessingUnit):

351

352

nReadBlocks = 0

352

nReadBlocks = 0

353

354

delay = 10 #number of seconds waiting a new file

354

delay = 10 #number of seconds waiting a new file

355

356

nTries = 3 #quantity tries

356

nTries = 3 #quantity tries

357

358

nFiles = 3 #number of files for searching

358

nFiles = 3 #number of files for searching

359

360

path = None

360

path = None

361

362

foldercounter = 0

362

foldercounter = 0

363

364

flagNoMoreFiles = 0

364

flagNoMoreFiles = 0

365

366

datetimeList = []

366

datetimeList = []

367

368

__isFirstTimeOnline = 1

368

__isFirstTimeOnline = 1

369

370

__printInfo = True

370

__printInfo = True

371

372

profileIndex = None

372

profileIndex = None

373

374

def __init__(self):

374

def __init__(self):

375

376

"""

376

"""

377

378

"""

378

"""

379

380

raise ValueError, "This method has not been implemented"

380

raise ValueError, "This method has not been implemented"

381

382

383

def createObjByDefault(self):

383

def createObjByDefault(self):

384

"""

384

"""

385

386

"""

386

"""

387

raise ValueError, "This method has not been implemented"

387

raise ValueError, "This method has not been implemented"

388

389

def getBlockDimension(self):

389

def getBlockDimension(self):

390

391

raise ValueError, "No implemented"

391

raise ValueError, "No implemented"

392

393

def __searchFilesOffLine(self,

393

def __searchFilesOffLine(self,

394

path,

394

path,

395

startDate,

395

startDate,

396

endDate,

396

endDate,

397

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

397

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

398

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

398

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

399

set=None,

399

set=None,

400

expLabel='',

400

expLabel='',

401

ext='.r',

401

ext='.r',

402

walk=True):

402

walk=True):

403

404

pathList = []

404

pathList = []

405

406

if not walk:

406

if not walk:

407

#pathList.append(path)

407

#pathList.append(path)

408

multi_path = path.split(',')

408

multi_path = path.split(',')

409

for single_path in multi_path:

409

for single_path in multi_path:

410

pathList.append(single_path)

410

pathList.append(single_path)

411

412

else:

412

else:

413

#dirList = []

413

#dirList = []

414

multi_path = path.split(',')

414

multi_path = path.split(',')

415

for single_path in multi_path:

415

for single_path in multi_path:

416

dirList = []

416

dirList = []

417

for thisPath in os.listdir(single_path):

417

for thisPath in os.listdir(single_path):

418

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

418

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

419

continue

419

continue

420

if not isDoyFolder(thisPath):

420

if not isDoyFolder(thisPath):

421

continue

421

continue

422

423

dirList.append(thisPath)

423

dirList.append(thisPath)

424

425

if not(dirList):

425

if not(dirList):

426

return None, None

426

return None, None

427

428

thisDate = startDate

428

thisDate = startDate

429

430

while(thisDate <= endDate):

430

while(thisDate <= endDate):

431

year = thisDate.timetuple().tm_year

431

year = thisDate.timetuple().tm_year

432

doy = thisDate.timetuple().tm_yday

432

doy = thisDate.timetuple().tm_yday

433

434

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

434

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

435

if len(matchlist) == 0:

435

if len(matchlist) == 0:

436

thisDate += datetime.timedelta(1)

436

thisDate += datetime.timedelta(1)

437

continue

437

continue

438

for match in matchlist:

438

for match in matchlist:

439

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

439

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

440

441

thisDate += datetime.timedelta(1)

441

thisDate += datetime.timedelta(1)

442

443

if pathList == []:

443

if pathList == []:

444

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

444

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

445

return None, None

445

return None, None

446

447

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

447

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

448

449

filenameList = []

449

filenameList = []

450

datetimeList = []

450

datetimeList = []

451

pathDict = {}

451

pathDict = {}

452

filenameList_to_sort = []

452

filenameList_to_sort = []

453

454

for i in range(len(pathList)):

454

for i in range(len(pathList)):

455

456

thisPath = pathList[i]

456

thisPath = pathList[i]

457

458

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

458

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

459

fileList.sort()

459

fileList.sort()

460

pathDict.setdefault(fileList[0])

460

pathDict.setdefault(fileList[0])

461

pathDict[fileList[0]] = i

461

pathDict[fileList[0]] = i

462

filenameList_to_sort.append(fileList[0])

462

filenameList_to_sort.append(fileList[0])

463

464

filenameList_to_sort.sort()

464

filenameList_to_sort.sort()

465

466

for file in filenameList_to_sort:

466

for file in filenameList_to_sort:

467

thisPath = pathList[pathDict[file]]

467

thisPath = pathList[pathDict[file]]

468

469

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

469

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

470

fileList.sort()

470

fileList.sort()

471

472

for file in fileList:

472

for file in fileList:

473

474

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

474

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

475

thisDatetime = isFileinThisTime(filename, startTime, endTime)

475

thisDatetime = isFileinThisTime(filename, startTime, endTime)

476

477

if not(thisDatetime):

477

if not(thisDatetime):

478

continue

478

continue

479

480

filenameList.append(filename)

480

filenameList.append(filename)

481

datetimeList.append(thisDatetime)

481

datetimeList.append(thisDatetime)

482

483

if not(filenameList):

483

if not(filenameList):

484

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

484

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

485

return None, None

485

return None, None

486

487

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

487

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

488

print

488

print

489

490

for i in range(len(filenameList)):

490

for i in range(len(filenameList)):

491

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

491

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

492

493

self.filenameList = filenameList

493

self.filenameList = filenameList

494

self.datetimeList = datetimeList

494

self.datetimeList = datetimeList

495

496

return pathList, filenameList

496

return pathList, filenameList

497

498

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

498

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

499

500

"""

500

"""

501

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

501

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

502

devuelve el archivo encontrado ademas de otros datos.

502

devuelve el archivo encontrado ademas de otros datos.

503

504

Input:

504

Input:

505

path : carpeta donde estan contenidos los files que contiene data

505

path : carpeta donde estan contenidos los files que contiene data

506

507

expLabel : Nombre del subexperimento (subfolder)

507

expLabel : Nombre del subexperimento (subfolder)

508

509

ext : extension de los files

509

ext : extension de los files

510

511

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

511

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

512

513

Return:

513

Return:

514

directory : eL directorio donde esta el file encontrado

514

directory : eL directorio donde esta el file encontrado

515

filename : el ultimo file de una determinada carpeta

515

filename : el ultimo file de una determinada carpeta

516

year : el anho

516

year : el anho

517

doy : el numero de dia del anho

517

doy : el numero de dia del anho

518

set : el set del archivo

518

set : el set del archivo

519

520

521

"""

521

"""

522

dirList = []

522

dirList = []

523

524

if not walk:

524

if not walk:

525

fullpath = path

525

fullpath = path

526

foldercounter = 0

526

foldercounter = 0

527

else:

527

else:

528

#Filtra solo los directorios

528

#Filtra solo los directorios

529

for thisPath in os.listdir(path):

529

for thisPath in os.listdir(path):

530

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

530

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

531

continue

531

continue

532

if not isDoyFolder(thisPath):

532

if not isDoyFolder(thisPath):

533

continue

533

continue

534

535

dirList.append(thisPath)

535

dirList.append(thisPath)

536

537

if not(dirList):

537

if not(dirList):

538

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

538

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

539

540

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

540

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

541

542

doypath = dirList[-1]

542

doypath = dirList[-1]

543

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

543

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

544

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

544

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

545

546

547

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

547

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

548

549

if set == None:

549

if set == None:

550

filename = getlastFileFromPath(fullpath, ext)

550

filename = getlastFileFromPath(fullpath, ext)

551

else:

551

else:

552

filename = getFileFromSet(fullpath, ext, set)

552

filename = getFileFromSet(fullpath, ext, set)

553

554

if not(filename):

554

if not(filename):

555

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

555

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

556

557

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

557

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

558

559

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

559

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

560

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

560

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

561

562

year = int( filename[1:5] )

562

year = int( filename[1:5] )

563

doy = int( filename[5:8] )

563

doy = int( filename[5:8] )

564

set = int( filename[8:11] )

564

set = int( filename[8:11] )

565

566

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

566

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

567

568

def __setNextFileOffline(self):

568

def __setNextFileOffline(self):

569

570

idFile = self.fileIndex

570

idFile = self.fileIndex

571

572

while (True):

572

while (True):

573

idFile += 1

573

idFile += 1

574

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

574

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

575

self.flagNoMoreFiles = 1

575

self.flagNoMoreFiles = 1

576

print "No more Files"

576

print "No more Files"

577

return 0

577

return 0

578

579

filename = self.filenameList[idFile]

579

filename = self.filenameList[idFile]

580

581

if not(self.__verifyFile(filename)):

581

if not(self.__verifyFile(filename)):

582

continue

582

continue

583

584

fileSize = os.path.getsize(filename)

584

fileSize = os.path.getsize(filename)

585

fp = open(filename,'rb')

585

fp = open(filename,'rb')

586

break

586

break

587

588

self.flagIsNewFile = 1

588

self.flagIsNewFile = 1

589

self.fileIndex = idFile

589

self.fileIndex = idFile

590

self.filename = filename

590

self.filename = filename

591

self.fileSize = fileSize

591

self.fileSize = fileSize

592

self.fp = fp

592

self.fp = fp

593

594

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

594

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

595

596

return 1

596

return 1

597

598

def __setNextFileOnline(self):

598

def __setNextFileOnline(self):

599

"""

599

"""

600

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

600

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

601

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

601

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

602

siguientes.

602

siguientes.

603

604

Affected:

604

Affected:

605

self.flagIsNewFile

605

self.flagIsNewFile

606

self.filename

606

self.filename

607

self.fileSize

607

self.fileSize

608

self.fp

608

self.fp

609

self.set

609

self.set

610

self.flagNoMoreFiles

610

self.flagNoMoreFiles

611

612

Return:

612

Return:

613

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

613

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

614

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

614

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

615

616

Excepciones:

616

Excepciones:

617

Si un determinado file no puede ser abierto

617

Si un determinado file no puede ser abierto

618

"""

618

"""

619

nFiles = 0

619

nFiles = 0

620

fileOk_flag = False

620

fileOk_flag = False

621

firstTime_flag = True

621

firstTime_flag = True

622

623

self.set += 1

623

self.set += 1

624

625

if self.set > 999:

625

if self.set > 999:

626

self.set = 0

626

self.set = 0

627

self.foldercounter += 1

627

self.foldercounter += 1

628

629

#busca el 1er file disponible

629

#busca el 1er file disponible

630

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

630

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

631

if fullfilename:

631

if fullfilename:

632

if self.__verifyFile(fullfilename, False):

632

if self.__verifyFile(fullfilename, False):

633

fileOk_flag = True

633

fileOk_flag = True

634

635

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

635

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

636

if not(fileOk_flag):

636

if not(fileOk_flag):

637

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

637

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

638

639

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

639

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

640

tries = self.nTries

640

tries = self.nTries

641

else:

641

else:

642

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

642

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

643

644

for nTries in range( tries ):

644

for nTries in range( tries ):

645

if firstTime_flag:

645

if firstTime_flag:

646

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

646

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

647

time.sleep( self.delay )

647

time.sleep( self.delay )

648

else:

648

else:

649

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

649

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

650

651

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

651

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

652

if fullfilename:

652

if fullfilename:

653

if self.__verifyFile(fullfilename):

653

if self.__verifyFile(fullfilename):

654

fileOk_flag = True

654

fileOk_flag = True

655

break

655

break

656

657

if fileOk_flag:

657

if fileOk_flag:

658

break

658

break

659

660

firstTime_flag = False

660

firstTime_flag = False

661

662

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

662

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

663

self.set += 1

663

self.set += 1

664

665

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

665

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

666

self.set = 0

666

self.set = 0

667

self.doy += 1

667

self.doy += 1

668

self.foldercounter = 0

668

self.foldercounter = 0

669

670

if fileOk_flag:

670

if fileOk_flag:

671

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

671

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

672

self.filename = fullfilename

672

self.filename = fullfilename

673

self.flagIsNewFile = 1

673

self.flagIsNewFile = 1

674

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

674

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

675

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

675

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

676

self.flagNoMoreFiles = 0

676

self.flagNoMoreFiles = 0

677

print 'Setting the file: %s' % fullfilename

677

print 'Setting the file: %s' % fullfilename

678

else:

678

else:

679

self.fileSize = 0

679

self.fileSize = 0

680

self.filename = None

680

self.filename = None

681

self.flagIsNewFile = 0

681

self.flagIsNewFile = 0

682

self.fp = None

682

self.fp = None

683

self.flagNoMoreFiles = 1

683

self.flagNoMoreFiles = 1

684

print 'No more Files'

684

print 'No more Files'

685

686

return fileOk_flag

686

return fileOk_flag

687

688

689

def setNextFile(self):

689

def setNextFile(self):

690

if self.fp != None:

690

if self.fp != None:

691

self.fp.close()

691

self.fp.close()

692

693

if self.online:

693

if self.online:

694

newFile = self.__setNextFileOnline()

694

newFile = self.__setNextFileOnline()

695

else:

695

else:

696

newFile = self.__setNextFileOffline()

696

newFile = self.__setNextFileOffline()

697

698

if not(newFile):

698

if not(newFile):

699

return 0

699

return 0

700

701

self.__readFirstHeader()

701

self.__readFirstHeader()

702

self.nReadBlocks = 0

702

self.nReadBlocks = 0

703

return 1

703

return 1

704

705

def __waitNewBlock(self):

705

def __waitNewBlock(self):

706

"""

706

"""

707

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

707

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

708

709

Si el modo de lectura es OffLine siempre retorn 0

709

Si el modo de lectura es OffLine siempre retorn 0

710

"""

710

"""

711

if not self.online:

711

if not self.online:

712

return 0

712

return 0

713

714

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

714

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

715

return 0

715

return 0

716

717

currentPointer = self.fp.tell()

717

currentPointer = self.fp.tell()

718

719

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

719

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

720

721

for nTries in range( self.nTries ):

721

for nTries in range( self.nTries ):

722

723

self.fp.close()

723

self.fp.close()

724

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

724

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

725

self.fp.seek( currentPointer )

725

self.fp.seek( currentPointer )

726

727

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

727

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

728

currentSize = self.fileSize - currentPointer

728

currentSize = self.fileSize - currentPointer

729

730

if ( currentSize >= neededSize ):

730

if ( currentSize >= neededSize ):

731

self.__rdBasicHeader()

731

self.__rdBasicHeader()

732

return 1

732

return 1

733

734

if self.fileSize == self.fileSizeByHeader:

734

if self.fileSize == self.fileSizeByHeader:

735

# self.flagEoF = True

735

# self.flagEoF = True

736

return 0

736

return 0

737

738

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

738

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

739

time.sleep( self.delay )

739

time.sleep( self.delay )

740

741

742

return 0

742

return 0

743

744

def waitDataBlock(self,pointer_location):

744

def waitDataBlock(self,pointer_location):

745

746

currentPointer = pointer_location

746

currentPointer = pointer_location

747

748

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

748

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

749

750

for nTries in range( self.nTries ):

750

for nTries in range( self.nTries ):

751

self.fp.close()

751

self.fp.close()

752

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

752

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

753

self.fp.seek( currentPointer )

753

self.fp.seek( currentPointer )

754

755

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

755

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

756

currentSize = self.fileSize - currentPointer

756

currentSize = self.fileSize - currentPointer

757

758

if ( currentSize >= neededSize ):

758

if ( currentSize >= neededSize ):

759

return 1

759

return 1

760

761

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

761

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

762

time.sleep( self.delay )

762

time.sleep( self.delay )

763

764

return 0

764

return 0

765

766

767

def __jumpToLastBlock(self):

767

def __jumpToLastBlock(self):

768

769

if not(self.__isFirstTimeOnline):

769

if not(self.__isFirstTimeOnline):

770

return

770

return

771

772

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

772

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

773

blocksize = self.processingHeaderObj.blockSize

773

blocksize = self.processingHeaderObj.blockSize

774

775

#salta el primer bloque de datos

775

#salta el primer bloque de datos

776

if csize > self.processingHeaderObj.blockSize:

776

if csize > self.processingHeaderObj.blockSize:

777

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

777

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

778

else:

778

else:

779

return

779

return

780

781

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

781

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

782

neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

782

neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

783

while True:

783

while True:

784

785

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

785

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

786

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

786

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

787

else:

787

else:

788

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

788

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

789

break

789

break

790

791

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

791

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

792

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

792

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

793

# factor = int(csize/neededsize)

793

# factor = int(csize/neededsize)

794

# if factor > 0:

794

# if factor > 0:

795

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

795

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

796

797

self.flagIsNewFile = 0

797

self.flagIsNewFile = 0

798

self.__isFirstTimeOnline = 0

798

self.__isFirstTimeOnline = 0

799

800

801

def __setNewBlock(self):

801

def __setNewBlock(self):

802

803

if self.fp == None:

803

if self.fp == None:

804

return 0

804

return 0

805

806

if self.online:

806

if self.online:

807

self.__jumpToLastBlock()

807

self.__jumpToLastBlock()

808

809

if self.flagIsNewFile:

809

if self.flagIsNewFile:

810

return 1

810

return 1

811

812

self.lastUTTime = self.basicHeaderObj.utc

812

self.lastUTTime = self.basicHeaderObj.utc

813

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

813

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

814

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

814

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

815

816

if (currentSize >= neededSize):

816

if (currentSize >= neededSize):

817

self.__rdBasicHeader()

817

self.__rdBasicHeader()

818

return 1

818

return 1

819

820

if self.__waitNewBlock():

820

if self.__waitNewBlock():

821

return 1

821

return 1

822

823

if not(self.setNextFile()):

823

if not(self.setNextFile()):

824

return 0

824

return 0

825

826

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

826

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

827

828

self.flagTimeBlock = 0

828

self.flagTimeBlock = 0

829

830

if deltaTime > self.maxTimeStep:

830

if deltaTime > self.maxTimeStep:

831

self.flagTimeBlock = 1

831

self.flagTimeBlock = 1

832

833

return 1

833

return 1

834

835

836

def readNextBlock(self):

836

def readNextBlock(self):

837

if not(self.__setNewBlock()):

837

if not(self.__setNewBlock()):

838

return 0

838

return 0

839

840

if not(self.readBlock()):

840

if not(self.readBlock()):

841

return 0

841

return 0

842

843

return 1

843

return 1

844

845

def __rdProcessingHeader(self, fp=None):

845

def __rdProcessingHeader(self, fp=None):

846

if fp == None:

846

if fp == None:

847

fp = self.fp

847

fp = self.fp

848

849

self.processingHeaderObj.read(fp)

849

self.processingHeaderObj.read(fp)

850

851

def __rdRadarControllerHeader(self, fp=None):

851

def __rdRadarControllerHeader(self, fp=None):

852

if fp == None:

852

if fp == None:

853

fp = self.fp

853

fp = self.fp

854

855

self.radarControllerHeaderObj.read(fp)

855

self.radarControllerHeaderObj.read(fp)

856

857

def __rdSystemHeader(self, fp=None):

857

def __rdSystemHeader(self, fp=None):

858

if fp == None:

858

if fp == None:

859

fp = self.fp

859

fp = self.fp

860

861

self.systemHeaderObj.read(fp)

861

self.systemHeaderObj.read(fp)

862

863

def __rdBasicHeader(self, fp=None):

863

def __rdBasicHeader(self, fp=None):

864

if fp == None:

864

if fp == None:

865

fp = self.fp

865

fp = self.fp

866

867

self.basicHeaderObj.read(fp)

867

self.basicHeaderObj.read(fp)

868

869

870

def __readFirstHeader(self):

870

def __readFirstHeader(self):

871

self.__rdBasicHeader()

871

self.__rdBasicHeader()

872

self.__rdSystemHeader()

872

self.__rdSystemHeader()

873

self.__rdRadarControllerHeader()

873

self.__rdRadarControllerHeader()

874

self.__rdProcessingHeader()

874

self.__rdProcessingHeader()

875

876

self.firstHeaderSize = self.basicHeaderObj.size

876

self.firstHeaderSize = self.basicHeaderObj.size

877

878

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

878

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

879

if datatype == 0:

879

if datatype == 0:

880

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

880

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

881

elif datatype == 1:

881

elif datatype == 1:

882

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

882

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

883

elif datatype == 2:

883

elif datatype == 2:

884

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

884

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

885

elif datatype == 3:

885

elif datatype == 3:

886

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

886

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

887

elif datatype == 4:

887

elif datatype == 4:

888

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

888

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

889

elif datatype == 5:

889

elif datatype == 5:

890

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

890

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

891

else:

891

else:

892

raise ValueError, 'Data type was not defined'

892

raise ValueError, 'Data type was not defined'

893

894

self.dtype = datatype_str

894

self.dtype = datatype_str

895

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

895

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

896

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

896

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

897

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

897

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

898

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

898

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

899

self.getBlockDimension()

899

self.getBlockDimension()

900

901

902

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

902

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

903

msg = None

903

msg = None

904

try:

904

try:

905

fp = open(filename, 'rb')

905

fp = open(filename, 'rb')

906

currentPosition = fp.tell()

906

currentPosition = fp.tell()

907

except:

907

except:

908

if msgFlag:

908

if msgFlag:

909

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

909

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

910

return False

910

return False

911

912

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

912

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

913

914

if neededSize == 0:

914

if neededSize == 0:

915

basicHeaderObj = BasicHeader(LOCALTIME)

915

basicHeaderObj = BasicHeader(LOCALTIME)

916

systemHeaderObj = SystemHeader()

916

systemHeaderObj = SystemHeader()

917

radarControllerHeaderObj = RadarControllerHeader()

917

radarControllerHeaderObj = RadarControllerHeader()

918

processingHeaderObj = ProcessingHeader()

918

processingHeaderObj = ProcessingHeader()

919

920

try:

920

try:

921

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

921

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

922

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

922

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

923

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

923

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

924

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

924

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

925

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

925

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

926

927

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

927

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

928

929

except:

929

except:

930

if msgFlag:

930

if msgFlag:

931

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

931

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

932

933

fp.close()

933

fp.close()

934

return False

934

return False

935

else:

935

else:

936

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

936

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

937

938

fp.close()

938

fp.close()

939

fileSize = os.path.getsize(filename)

939

fileSize = os.path.getsize(filename)

940

currentSize = fileSize - currentPosition

940

currentSize = fileSize - currentPosition

941

if currentSize < neededSize:

941

if currentSize < neededSize:

942

if msgFlag and (msg != None):

942

if msgFlag and (msg != None):

943

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

943

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

944

return False

944

return False

945

946

return True

946

return True

947

948

def setup(self,

948

def setup(self,

949

path=None,

949

path=None,

950

startDate=None,

950

startDate=None,

951

endDate=None,

951

endDate=None,

952

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

952

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

953

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

953

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

954

set=None,

954

set=None,

955

expLabel = "",

955

expLabel = "",

956

ext = None,

956

ext = None,

957

online = False,

957

online = False,

958

delay = 60,

958

delay = 60,

959

walk = True):

959

walk = True):

960

961

if path == None:

961

if path == None:

962

raise ValueError, "The path is not valid"

962

raise ValueError, "The path is not valid"

963

964

if ext == None:

964

if ext == None:

965

ext = self.ext

965

ext = self.ext

966

967

if online:

967

if online:

968

print "Searching files in online mode..."

968

print "Searching files in online mode..."

969

970

for nTries in range( self.nTries ):

970

for nTries in range( self.nTries ):

971

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

971

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

972

973

if fullpath:

973

if fullpath:

974

break

974

break

975

976

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

976

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

977

time.sleep( self.delay )

977

time.sleep( self.delay )

978

979

if not(fullpath):

979

if not(fullpath):

980

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

980

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

981

return None

981

return None

982

983

self.year = year

983

self.year = year

984

self.doy = doy

984

self.doy = doy

985

self.set = set - 1

985

self.set = set - 1

986

self.path = path

986

self.path = path

987

self.foldercounter = foldercounter

987

self.foldercounter = foldercounter

988

last_set = None

988

989

else:

990

else:

990

print "Searching files in offline mode ..."

991

print "Searching files in offline mode ..."

991

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

992

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

992

startTime=startTime, endTime=endTime,

993

startTime=startTime, endTime=endTime,

993

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

994

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

994

walk=walk)

995

walk=walk)

995

996

if not(pathList):

997

if not(pathList):

997

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

998

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

998

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

999

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

999

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

1000

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

1000

1001

sys.exit(-1)

1002

sys.exit(-1)

1002

1003

1004

self.fileIndex = -1

1005

self.fileIndex = -1

1005

self.pathList = pathList

1006

self.pathList = pathList

1006

self.filenameList = filenameList

1007

self.filenameList = filenameList

1007

1008

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

1009

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

1010

last_set = int(basename[-3:])

1011

1008

self.online = online

1012

self.online = online

1009

self.delay = delay

1013

self.delay = delay

1010

ext = ext.lower()

1014

ext = ext.lower()

1011

self.ext = ext

1015

self.ext = ext

1012

1016

1013

if not(self.setNextFile()):

1017

if not(self.setNextFile()):

1014

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

1018

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

1015

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

1019

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

1016

elif startDate != None:

1020

elif startDate != None:

1017

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

1021

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

1018

else:

1022

else:

1019

print "No files"

1023

print "No files"

1020

1024

1021

sys.exit(-1)

1025

sys.exit(-1)

1022

1026

1023

# self.updateDataHeader()

1027

# self.updateDataHeader()

1024

1028

if last_set != None:

1029

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

1025

return self.dataOut

1030

return self.dataOut

1026

1031

1027

def getBasicHeader(self):

1032

def getBasicHeader(self):

1028

1033

1029

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

1034

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

1030

1035

1031

self.dataOut.flagTimeBlock = self.flagTimeBlock

1036

self.dataOut.flagTimeBlock = self.flagTimeBlock

1032

1037

1033

self.dataOut.timeZone = self.basicHeaderObj.timeZone

1038

self.dataOut.timeZone = self.basicHeaderObj.timeZone

1034

1039

1035

self.dataOut.dstFlag = self.basicHeaderObj.dstFlag

1040

self.dataOut.dstFlag = self.basicHeaderObj.dstFlag

1036

1041

1037

self.dataOut.errorCount = self.basicHeaderObj.errorCount

1042

self.dataOut.errorCount = self.basicHeaderObj.errorCount

1038

1043

1039

self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime

1044

self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime

1040

1045

1041

def getFirstHeader(self):

1046

def getFirstHeader(self):

1042

1047

1043

raise ValueError, "This method has not been implemented"

1048

raise ValueError, "This method has not been implemented"

1044

1049

1045

def getData():

1050

def getData():

1046

1051

1047

raise ValueError, "This method has not been implemented"

1052

raise ValueError, "This method has not been implemented"

1048

1053

1049

def hasNotDataInBuffer():

1054

def hasNotDataInBuffer():

1050

1055

1051

raise ValueError, "This method has not been implemented"

1056

raise ValueError, "This method has not been implemented"

1052

1057

1053

def readBlock():

1058

def readBlock():

1054

1059

1055

raise ValueError, "This method has not been implemented"

1060

raise ValueError, "This method has not been implemented"

1056

1061

1057

def isEndProcess(self):

1062

def isEndProcess(self):

1058

1063

1059

return self.flagNoMoreFiles

1064

return self.flagNoMoreFiles

1060

1065

1061

def printReadBlocks(self):

1066

def printReadBlocks(self):

1062

1067

1063

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

1068

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

1064

1069

1065

def printTotalBlocks(self):

1070

def printTotalBlocks(self):

1066

1071

1067

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

1072

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

1068

1073

1069

def printNumberOfBlock(self):

1074

def printNumberOfBlock(self):

1070

1075

1071

if self.flagIsNewBlock:

1076

if self.flagIsNewBlock:

1072

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

1077

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

1073

1078

self.dataOut.blocknow = self.basicHeaderObj.dataBlock

1074

def printInfo(self):

1079

def printInfo(self):

1075

1080

1076

if self.__printInfo == False:

1081

if self.__printInfo == False:

1077

return

1082

return

1078

1083

1079

self.basicHeaderObj.printInfo()

1084

self.basicHeaderObj.printInfo()

1080

self.systemHeaderObj.printInfo()

1085

self.systemHeaderObj.printInfo()

1081

self.radarControllerHeaderObj.printInfo()

1086

self.radarControllerHeaderObj.printInfo()

1082

self.processingHeaderObj.printInfo()

1087

self.processingHeaderObj.printInfo()

1083

1088

1084

self.__printInfo = False

1089

self.__printInfo = False

1085

1090

1086

1091

1087

def run(self, **kwargs):

1092

def run(self, **kwargs):

1088

1093

1089

if not(self.isConfig):

1094

if not(self.isConfig):

1090

1095

1091

# self.dataOut = dataOut

1096

# self.dataOut = dataOut

1092

self.setup(**kwargs)

1097

self.setup(**kwargs)

1093

self.isConfig = True

1098

self.isConfig = True

1094

1099

1095

self.getData()

1100

self.getData()

1096

1101

1097

class JRODataWriter(JRODataIO, Operation):

1102

class JRODataWriter(JRODataIO, Operation):

1098

1103

1099

"""

1104

"""

1100

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

1105

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

1101

de los datos siempre se realiza por bloques.

1106

de los datos siempre se realiza por bloques.

1102

"""

1107

"""

1103

1108

1104

blockIndex = 0

1109

blockIndex = 0

1105

1110

1106

path = None

1111

path = None

1107

1112

1108

setFile = None

1113

setFile = None

1109

1114

1110

profilesPerBlock = None

1115

profilesPerBlock = None

1111

1116

1112

blocksPerFile = None

1117

blocksPerFile = None

1113

1118

1114

nWriteBlocks = 0

1119

nWriteBlocks = 0

1115

1120

1116

def __init__(self, dataOut=None):

1121

def __init__(self, dataOut=None):

1117

raise ValueError, "Not implemented"

1122

raise ValueError, "Not implemented"

1118

1123

1119

1124

1120

def hasAllDataInBuffer(self):

1125

def hasAllDataInBuffer(self):

1121

raise ValueError, "Not implemented"

1126

raise ValueError, "Not implemented"

1122

1127

1123

1128

1124

def setBlockDimension(self):

1129

def setBlockDimension(self):

1125

raise ValueError, "Not implemented"

1130

raise ValueError, "Not implemented"

1126

1131

1127

1132

1128

def writeBlock(self):

1133

def writeBlock(self):

1129

raise ValueError, "No implemented"

1134

raise ValueError, "No implemented"

1130

1135

1131

1136

1132

def putData(self):

1137

def putData(self):

1133

raise ValueError, "No implemented"

1138

raise ValueError, "No implemented"

1134

1139

1135

1140

1136

def setBasicHeader(self):

1141

def setBasicHeader(self):

1137

1142

1138

self.basicHeaderObj.size = self.basicHeaderSize #bytes

1143

self.basicHeaderObj.size = self.basicHeaderSize #bytes

1139

self.basicHeaderObj.version = self.versionFile

1144

self.basicHeaderObj.version = self.versionFile

1140

self.basicHeaderObj.dataBlock = self.nTotalBlocks

1145

self.basicHeaderObj.dataBlock = self.nTotalBlocks

1141

1146

1142

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

1147

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

1143

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

1148

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

1144

1149

1145

self.basicHeaderObj.utc = utc

1150

self.basicHeaderObj.utc = utc

1146

self.basicHeaderObj.miliSecond = milisecond

1151

self.basicHeaderObj.miliSecond = milisecond

1147

self.basicHeaderObj.timeZone = self.dataOut.timeZone

1152

self.basicHeaderObj.timeZone = self.dataOut.timeZone

1148

self.basicHeaderObj.dstFlag = self.dataOut.dstFlag

1153

self.basicHeaderObj.dstFlag = self.dataOut.dstFlag

1149

self.basicHeaderObj.errorCount = self.dataOut.errorCount

1154

self.basicHeaderObj.errorCount = self.dataOut.errorCount

1150

1155

1151

def setFirstHeader(self):

1156

def setFirstHeader(self):

1152

"""

1157

"""

1153

Obtiene una copia del First Header

1158

Obtiene una copia del First Header

1154

1159

1155

Affected:

1160

Affected:

1156

1161

1157

self.basicHeaderObj

1162

self.basicHeaderObj

1158

self.systemHeaderObj

1163

self.systemHeaderObj

1159

self.radarControllerHeaderObj

1164

self.radarControllerHeaderObj

1160

self.processingHeaderObj self.

1165

self.processingHeaderObj self.

1161

1166

1162

Return:

1167

Return:

1163

None

1168

None

1164

"""

1169

"""

1165

1170

1166

raise ValueError, "No implemented"

1171

raise ValueError, "No implemented"

1167

1172

1168

def __writeFirstHeader(self):

1173

def __writeFirstHeader(self):

1169

"""

1174

"""

1170

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

1175

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

1171

1176

1172

Affected:

1177

Affected:

1173

__dataType

1178

__dataType

1174

1179

1175

Return:

1180

Return:

1176

None

1181

None

1177

"""

1182

"""

1178

1183

1179

# CALCULAR PARAMETROS

1184

# CALCULAR PARAMETROS

1180

1185

1181

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

1186

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

1182

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

1187

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

1183

1188

1184

self.basicHeaderObj.write(self.fp)

1189

self.basicHeaderObj.write(self.fp)

1185

self.systemHeaderObj.write(self.fp)

1190

self.systemHeaderObj.write(self.fp)

1186

self.radarControllerHeaderObj.write(self.fp)

1191

self.radarControllerHeaderObj.write(self.fp)

1187

self.processingHeaderObj.write(self.fp)

1192

self.processingHeaderObj.write(self.fp)

1188

1193

1189

self.dtype = self.dataOut.dtype

1194

self.dtype = self.dataOut.dtype

1190

1195

1191

def __setNewBlock(self):

1196

def __setNewBlock(self):

1192

"""

1197

"""

1193

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

1198

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

1194

1199

1195

Return:

1200

Return:

1196

0 : si no pudo escribir nada

1201

0 : si no pudo escribir nada

1197

1 : Si escribio el Basic el First Header

1202

1 : Si escribio el Basic el First Header

1198

"""

1203

"""

1199

if self.fp == None:

1204

if self.fp == None:

1200

self.setNextFile()

1205

self.setNextFile()

1201

1206

1202

if self.flagIsNewFile:

1207

if self.flagIsNewFile:

1203

return 1

1208

return 1

1204

1209

1205

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

1210

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

1206

self.basicHeaderObj.write(self.fp)

1211

self.basicHeaderObj.write(self.fp)

1207

return 1

1212

return 1

1208

1213

1209

if not( self.setNextFile() ):

1214

if not( self.setNextFile() ):

1210

return 0

1215

return 0

1211

1216

1212

return 1

1217

return 1

1213

1218

1214

1219

1215

def writeNextBlock(self):

1220

def writeNextBlock(self):

1216

"""

1221

"""

1217

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

1222

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

1218

1223

1219

Return:

1224

Return:

1220

0 : Si no hizo pudo escribir el bloque de datos

1225

0 : Si no hizo pudo escribir el bloque de datos

1221

1 : Si no pudo escribir el bloque de datos

1226

1 : Si no pudo escribir el bloque de datos

1222

"""

1227

"""

1223

if not( self.__setNewBlock() ):

1228

if not( self.__setNewBlock() ):

1224

return 0

1229

return 0

1225

1230

1226

self.writeBlock()

1231

self.writeBlock()

1227

1232

1228

return 1

1233

return 1

1229

1234

1230

def setNextFile(self):

1235

def setNextFile(self):

1231

"""

1236

"""

1232

Determina el siguiente file que sera escrito

1237

Determina el siguiente file que sera escrito

1233

1238

1234

Affected:

1239

Affected:

1235

self.filename

1240

self.filename

1236

self.subfolder

1241

self.subfolder

1237

self.fp

1242

self.fp

1238

self.setFile

1243

self.setFile

1239

self.flagIsNewFile

1244

self.flagIsNewFile

1240

1245

1241

Return:

1246

Return:

1242

0 : Si el archivo no puede ser escrito

1247

0 : Si el archivo no puede ser escrito

1243

1 : Si el archivo esta listo para ser escrito

1248

1 : Si el archivo esta listo para ser escrito

1244

"""

1249

"""

1245

ext = self.ext

1250

ext = self.ext

1246

path = self.path

1251

path = self.path

1247

1252

1248

if self.fp != None:

1253

if self.fp != None:

1249

self.fp.close()

1254

self.fp.close()

1250

1255

1251

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

1256

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

1252

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

1257

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

1253

1258

1254

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

1259

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

1255

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

1260

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

1256

os.mkdir(fullpath)

1261

os.mkdir(fullpath)

1257

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

1262

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

1258

else:

1263

else:

1259

filesList = os.listdir( fullpath )

1264

filesList = os.listdir( fullpath )

1260

if len( filesList ) > 0:

1265

if len( filesList ) > 0:

1261

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

1266

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

1262

filen = filesList[-1]

1267

filen = filesList[-1]

1263

# el filename debera tener el siguiente formato

1268

# el filename debera tener el siguiente formato

1264

# 0 1234 567 89A BCDE (hex)

1269

# 0 1234 567 89A BCDE (hex)

1265

# x YYYY DDD SSS .ext

1270

# x YYYY DDD SSS .ext

1266

if isNumber( filen[8:11] ):

1271

if isNumber( filen[8:11] ):

1267

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

1272

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

1268

else:

1273

else:

1269

self.setFile = -1

1274

self.setFile = -1

1270

else:

1275

else:

1271

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

1276

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

1272

1277

1273

setFile = self.setFile

1278

setFile = self.setFile

1274

setFile += 1

1279

setFile += 1

1275

1280

1276

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

1281

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

1277

timeTuple.tm_year,

1282

timeTuple.tm_year,

1278

timeTuple.tm_yday,

1283

timeTuple.tm_yday,

1279

setFile,

1284

setFile,

1280

ext )

1285

ext )

1281

1286

1282

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

1287

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

1283

1288

1284

fp = open( filename,'wb' )

1289

fp = open( filename,'wb' )

1285

1290

1286

self.blockIndex = 0

1291

self.blockIndex = 0

1287

1292

1288

#guardando atributos

1293

#guardando atributos

1289

self.filename = filename

1294

self.filename = filename

1290

self.subfolder = subfolder

1295

self.subfolder = subfolder

1291

self.fp = fp

1296

self.fp = fp

1292

self.setFile = setFile

1297

self.setFile = setFile

1293

self.flagIsNewFile = 1

1298

self.flagIsNewFile = 1

1294

1299

1295

self.setFirstHeader()

1300

self.setFirstHeader()

1296

1301

1297

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

1302

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

1298

1303

1299

self.__writeFirstHeader()

1304

self.__writeFirstHeader()

1300

1305

1301

return 1

1306

return 1

1302

1307

1303

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

1308

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

1304

"""

1309

"""

1305

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

1310

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

1306

1311

1307

Inputs:

1312

Inputs:

1308

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

1313

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

1309

format : formato en el cual sera salvado un file

1314

format : formato en el cual sera salvado un file

1310

set : el setebo del file

1315

set : el setebo del file

1311

1316

1312

Return:

1317

Return:

1313

0 : Si no realizo un buen seteo

1318

0 : Si no realizo un buen seteo

1314

1 : Si realizo un buen seteo

1319

1 : Si realizo un buen seteo

1315

"""

1320

"""

1316

1321

1317

if ext == None:

1322

if ext == None:

1318

ext = self.ext

1323

ext = self.ext

1319

1324

1320

ext = ext.lower()

1325

ext = ext.lower()

1321

1326

1322

self.ext = ext

1327

self.ext = ext

1323

1328

1324

self.path = path

1329

self.path = path

1325

1330

1326

self.setFile = set - 1

1331

self.setFile = set - 1

1327

1332

1328

self.blocksPerFile = blocksPerFile

1333

self.blocksPerFile = blocksPerFile

1329

1334

1330

self.profilesPerBlock = profilesPerBlock

1335

self.profilesPerBlock = profilesPerBlock

1331

1336

1332

self.dataOut = dataOut

1337

self.dataOut = dataOut

1333

1338

1334

if not(self.setNextFile()):

1339

if not(self.setNextFile()):

1335

print "There isn't a next file"

1340

print "There isn't a next file"

1336

return 0

1341

return 0

1337

1342

1338

self.setBlockDimension()

1343

self.setBlockDimension()

1339

1344

1340

return 1

1345

return 1

1341

1346

1342

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

1347

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

1343

1348

1344

if not(self.isConfig):

1349

if not(self.isConfig):

1345

1350

1346

self.setup(dataOut, **kwargs)

1351

self.setup(dataOut, **kwargs)

1347

self.isConfig = True

1352

self.isConfig = True

1348

1353

1349

self.putData()

1354

self.putData()

1350

1355

1351

class VoltageReader(JRODataReader):

1356

class VoltageReader(JRODataReader):

1352

"""

1357

"""

1353

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

1358

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

1354

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

1359

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

1355

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

1360

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

1356

1361

1357

perfiles * alturas * canales

1362

perfiles * alturas * canales

1358

1363

1359

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

1364

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

1360

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

1365

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

1361

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

1366

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

1362

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

1367

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

1363

1368

1364

Example:

1369

Example:

1365

1370

1366

dpath = "/home/myuser/data"

1371

dpath = "/home/myuser/data"

1367

1372

1368

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

1373

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

1369

1374

1370

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

1375

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

1371

1376

1372

readerObj = VoltageReader()

1377

readerObj = VoltageReader()

1373

1378

1374

readerObj.setup(dpath, startTime, endTime)

1379

readerObj.setup(dpath, startTime, endTime)

1375

1380

1376

while(True):

1381

while(True):

1377

1382

1378

#to get one profile

1383

#to get one profile

1379

profile = readerObj.getData()

1384

profile = readerObj.getData()

1380

1385

1381

#print the profile

1386

#print the profile

1382

print profile

1387

print profile

1383

1388

1384

#If you want to see all datablock

1389

#If you want to see all datablock

1385

print readerObj.datablock

1390

print readerObj.datablock

1386

1391

1387

if readerObj.flagNoMoreFiles:

1392

if readerObj.flagNoMoreFiles:

1388

break

1393

break

1389

1394

1390

"""

1395

"""

1391

1396

1392

ext = ".r"

1397

ext = ".r"

1393

1398

1394

optchar = "D"

1399

optchar = "D"

1395

dataOut = None

1400

dataOut = None

1396

1401

1397

1402

1398

def __init__(self):

1403

def __init__(self):

1399

"""

1404

"""

1400

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

1405

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

1401

1406

1402

Input:

1407

Input:

1403

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

1408

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

1404

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

1409

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

1405

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

1410

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

1406

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

1411

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

1407

bloque de datos.

1412

bloque de datos.

1408

Si este parametro no es pasado se creara uno internamente.

1413

Si este parametro no es pasado se creara uno internamente.

1409

1414

1410

Variables afectadas:

1415

Variables afectadas:

1411

self.dataOut

1416

self.dataOut

1412

1417

1413

Return:

1418

Return:

1414

None

1419

None

1415

"""

1420

"""

1416

1421

1417

self.isConfig = False

1422

self.isConfig = False

1418

1423

1419

self.datablock = None

1424

self.datablock = None

1420

1425

1421

self.utc = 0

1426

self.utc = 0

1422

1427

1423

self.ext = ".r"

1428

self.ext = ".r"

1424

1429

1425

self.optchar = "D"

1430

self.optchar = "D"

1426

1431

1427

self.basicHeaderObj = BasicHeader(LOCALTIME)

1432

self.basicHeaderObj = BasicHeader(LOCALTIME)

1428

1433

1429

self.systemHeaderObj = SystemHeader()

1434

self.systemHeaderObj = SystemHeader()

1430

1435

1431

self.radarControllerHeaderObj = RadarControllerHeader()

1436

self.radarControllerHeaderObj = RadarControllerHeader()

1432

1437

1433

self.processingHeaderObj = ProcessingHeader()

1438

self.processingHeaderObj = ProcessingHeader()

1434

1439

1435

self.online = 0

1440

self.online = 0

1436

1441

1437

self.fp = None

1442

self.fp = None

1438

1443

1439

self.idFile = None

1444

self.idFile = None

1440

1445

1441

self.dtype = None

1446

self.dtype = None

1442

1447

1443

self.fileSizeByHeader = None

1448

self.fileSizeByHeader = None

1444

1449

1445

self.filenameList = []

1450

self.filenameList = []

1446

1451

1447

self.filename = None

1452

self.filename = None

1448

1453

1449

self.fileSize = None

1454

self.fileSize = None

1450

1455

1451

self.firstHeaderSize = 0

1456

self.firstHeaderSize = 0

1452

1457

1453

self.basicHeaderSize = 24

1458

self.basicHeaderSize = 24

1454

1459

1455

self.pathList = []

1460

self.pathList = []

1456

1461

1457

self.filenameList = []

1462

self.filenameList = []

1458

1463

1459

self.lastUTTime = 0

1464

self.lastUTTime = 0

1460

1465

1461

self.maxTimeStep = 30

1466

self.maxTimeStep = 30

1462

1467

1463

self.flagNoMoreFiles = 0

1468

self.flagNoMoreFiles = 0

1464

1469

1465

self.set = 0

1470

self.set = 0

1466

1471

1467

self.path = None

1472

self.path = None

1468

1473

1469

self.profileIndex = 2**32-1

1474

self.profileIndex = 2**32-1

1470

1475

1471

self.delay = 3 #seconds

1476

self.delay = 3 #seconds

1472

1477

1473

self.nTries = 3 #quantity tries

1478

self.nTries = 3 #quantity tries

1474

1479

1475

self.nFiles = 3 #number of files for searching

1480

self.nFiles = 3 #number of files for searching

1476

1481

1477

self.nReadBlocks = 0

1482

self.nReadBlocks = 0

1478

1483

1479

self.flagIsNewFile = 1

1484

self.flagIsNewFile = 1

1480

1485

1481

self.__isFirstTimeOnline = 1

1486

self.__isFirstTimeOnline = 1

1482

1487

1483

self.ippSeconds = 0

1488

self.ippSeconds = 0

1484

1489

1485

self.flagTimeBlock = 0

1490

self.flagTimeBlock = 0

1486

1491

1487

self.flagIsNewBlock = 0

1492

self.flagIsNewBlock = 0

1488

1493

1489

self.nTotalBlocks = 0

1494

self.nTotalBlocks = 0

1490

1495

1491

self.blocksize = 0

1496

self.blocksize = 0

1492

1497

1493

self.dataOut = self.createObjByDefault()

1498

self.dataOut = self.createObjByDefault()

1494

1499

1495

def createObjByDefault(self):

1500

def createObjByDefault(self):

1496

1501

1497

dataObj = Voltage()

1502

dataObj = Voltage()

1498

1503

1499

return dataObj

1504

return dataObj

1500

1505

1501

def __hasNotDataInBuffer(self):

1506

def __hasNotDataInBuffer(self):

1502

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

1507

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

1503

return 1

1508

return 1

1504

return 0

1509

return 0

1505

1510

1506

1511

1507

def getBlockDimension(self):

1512

def getBlockDimension(self):

1508

"""

1513

"""

1509

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

1514

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

1510

1515

1511

Affected:

1516

Affected:

1512

self.blocksize

1517

self.blocksize

1513

1518

1514

Return:

1519

Return:

1515

None

1520

None

1516

"""

1521

"""

1517

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

1522

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

1518

self.blocksize = pts2read

1523

self.blocksize = pts2read

1519

1524

1520

1525

1521

def readBlock(self):

1526

def readBlock(self):

1522

"""

1527

"""

1523

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

1528

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

1524

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

1529

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

1525

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

1530

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

1526

es seteado a 0

1531

es seteado a 0

1527

1532

1528

Inputs:

1533

Inputs:

1529

None

1534

None

1530

1535

1531

Return:

1536

Return:

1532

None

1537

None

1533

1538

1534

Affected:

1539

Affected:

1535

self.profileIndex

1540

self.profileIndex

1536

self.datablock

1541

self.datablock

1537

self.flagIsNewFile

1542

self.flagIsNewFile

1538

self.flagIsNewBlock

1543

self.flagIsNewBlock

1539

self.nTotalBlocks

1544

self.nTotalBlocks

1540

1545

1541

Exceptions:

1546

Exceptions:

1542

Si un bloque leido no es un bloque valido

1547

Si un bloque leido no es un bloque valido

1543

"""

1548

"""

1544

current_pointer_location = self.fp.tell()

1549

current_pointer_location = self.fp.tell()

1545

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

1550

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

1546

1551

1547

try:

1552

try:

1548

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

1553

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

1549

except:

1554

except:

1550

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

1555

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

1551

1556

1552

if self.waitDataBlock(pointer_location=current_pointer_location):

1557

if self.waitDataBlock(pointer_location=current_pointer_location):

1553

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

1558

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

1554

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

1559

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

1555

# return 0

1560

# return 0

1556

1561

1557

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

1562

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

1558

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

1563

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

1559

1564

1560

self.profileIndex = 0

1565

self.profileIndex = 0

1561

1566

1562

self.flagIsNewFile = 0

1567

self.flagIsNewFile = 0

1563

self.flagIsNewBlock = 1

1568

self.flagIsNewBlock = 1

1564

1569

1565

self.nTotalBlocks += 1

1570

self.nTotalBlocks += 1

1566

self.nReadBlocks += 1

1571

self.nReadBlocks += 1

1567

1572

1568

return 1

1573

return 1

1569

1574

1570

def getFirstHeader(self):

1575

def getFirstHeader(self):

1571

1576

1572

self.dataOut.dtype = self.dtype

1577

self.dataOut.dtype = self.dtype

1573

1578

1574

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1579

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1575

1580

1576

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

1581

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

1577

1582

1578

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

1583

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

1579

1584

1580

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

1585

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

1581

1586

1582

self.dataOut.ippSeconds = self.ippSeconds

1587

self.dataOut.ippSeconds = self.ippSeconds

1583

1588

1584

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

1589

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

1585

1590

1586

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1591

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1587

1592

1588

self.dataOut.flagShiftFFT = False

1593

self.dataOut.flagShiftFFT = False

1589

1594

1590

if self.radarControllerHeaderObj.code != None:

1595

if self.radarControllerHeaderObj.code != None:

1591

1596

1592

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1597

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1593

1598

1594

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1599

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1595

1600

1596

self.dataOut.code = self.radarControllerHeaderObj.code

1601

self.dataOut.code = self.radarControllerHeaderObj.code

1597

1602

1598

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

1603

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

1599

1604

1600

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

1605

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

1601

1606

1602

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

1607

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

1603

1608

1604

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

1609

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

1605

1610

1606

self.dataOut.flagShiftFFT = False

1611

self.dataOut.flagShiftFFT = False

1607

1612

1608

def getData(self):

1613

def getData(self):

1609

"""

1614

"""

1610

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

1615

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

1611

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

1616

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

1612

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

1617

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

1613

1618

1614

Ademas incrementa el contador del buffer en 1.

1619

Ademas incrementa el contador del buffer en 1.

1615

1620

1616

Return:

1621

Return:

1617

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

1622

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

1618

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

1623

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

1619

1624

1620

Variables afectadas:

1625

Variables afectadas:

1621

self.dataOut

1626

self.dataOut

1622

self.profileIndex

1627

self.profileIndex

1623

1628

1624

Affected:

1629

Affected:

1625

self.dataOut

1630

self.dataOut

1626

self.profileIndex

1631

self.profileIndex

1627

self.flagTimeBlock

1632

self.flagTimeBlock

1628

self.flagIsNewBlock

1633

self.flagIsNewBlock

1629

"""

1634

"""

1630

1635

1631

if self.flagNoMoreFiles:

1636

if self.flagNoMoreFiles:

1632

self.dataOut.flagNoData = True

1637

self.dataOut.flagNoData = True

1633

print 'Process finished'

1638

print 'Process finished'

1634

return 0

1639

return 0

1635

1640

1636

self.flagTimeBlock = 0

1641

self.flagTimeBlock = 0

1637

self.flagIsNewBlock = 0

1642

self.flagIsNewBlock = 0

1638

1643

1639

if self.__hasNotDataInBuffer():

1644

if self.__hasNotDataInBuffer():

1640

1645

1641

if not( self.readNextBlock() ):

1646

if not( self.readNextBlock() ):

1642

return 0

1647

return 0

1643

1648

1644

self.getFirstHeader()

1649

self.getFirstHeader()

1645

1650

1646

if self.datablock == None:

1651

if self.datablock == None:

1647

self.dataOut.flagNoData = True

1652

self.dataOut.flagNoData = True

1648

return 0

1653

return 0

1649

1654

1650

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

1655

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

1651

1656

1652

self.dataOut.flagNoData = False

1657

self.dataOut.flagNoData = False

1653

1658

1654

self.getBasicHeader()

1659

self.getBasicHeader()

1655

1660

1656

self.profileIndex += 1

1661

self.profileIndex += 1

1657

1662

1658

self.dataOut.realtime = self.online

1663

self.dataOut.realtime = self.online

1659

1664

1660

return self.dataOut.data

1665

return self.dataOut.data

1661

1666

1662

1667

1663

class VoltageWriter(JRODataWriter):

1668

class VoltageWriter(JRODataWriter):

1664

"""

1669

"""

1665

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

1670

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

1666

de los datos siempre se realiza por bloques.

1671

de los datos siempre se realiza por bloques.

1667

"""

1672

"""

1668

1673

1669

ext = ".r"

1674

ext = ".r"

1670

1675

1671

optchar = "D"

1676

optchar = "D"

1672

1677

1673

shapeBuffer = None

1678

shapeBuffer = None

1674

1679

1675

1680

1676

def __init__(self):

1681

def __init__(self):

1677

"""

1682

"""

1678

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

1683

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

1679

1684

1680

Affected:

1685

Affected:

1681

self.dataOut

1686

self.dataOut

1682

1687

1683

Return: None

1688

Return: None

1684

"""

1689

"""

1685

1690

1686

self.nTotalBlocks = 0

1691

self.nTotalBlocks = 0

1687

1692

1688

self.profileIndex = 0

1693

self.profileIndex = 0

1689

1694

1690

self.isConfig = False

1695

self.isConfig = False

1691

1696

1692

self.fp = None

1697

self.fp = None

1693

1698

1694

self.flagIsNewFile = 1

1699

self.flagIsNewFile = 1

1695

1700

1696

self.nTotalBlocks = 0

1701

self.nTotalBlocks = 0

1697

1702

1698

self.flagIsNewBlock = 0

1703

self.flagIsNewBlock = 0

1699

1704

1700

self.setFile = None

1705

self.setFile = None

1701

1706

1702

self.dtype = None

1707

self.dtype = None

1703

1708

1704

self.path = None

1709

self.path = None

1705

1710

1706

self.filename = None

1711

self.filename = None

1707

1712

1708

self.basicHeaderObj = BasicHeader(LOCALTIME)

1713

self.basicHeaderObj = BasicHeader(LOCALTIME)

1709

1714

1710

self.systemHeaderObj = SystemHeader()

1715

self.systemHeaderObj = SystemHeader()

1711

1716

1712

self.radarControllerHeaderObj = RadarControllerHeader()

1717

self.radarControllerHeaderObj = RadarControllerHeader()

1713

1718

1714

self.processingHeaderObj = ProcessingHeader()

1719

self.processingHeaderObj = ProcessingHeader()

1715

1720

1716

def hasAllDataInBuffer(self):

1721

def hasAllDataInBuffer(self):

1717

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

1722

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

1718

return 1

1723

return 1

1719

return 0

1724

return 0

1720

1725

1721

1726

1722

def setBlockDimension(self):

1727

def setBlockDimension(self):

1723

"""

1728

"""

1724

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

1729

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

1725

1730

1726

Affected:

1731

Affected:

1727

self.shape_spc_Buffer

1732

self.shape_spc_Buffer

1728

self.shape_cspc_Buffer

1733

self.shape_cspc_Buffer

1729

self.shape_dc_Buffer

1734

self.shape_dc_Buffer

1730

1735

1731

Return: None

1736

Return: None

1732

"""

1737

"""

1733

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1738

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1734

self.processingHeaderObj.nHeights,

1739

self.processingHeaderObj.nHeights,

1735

self.systemHeaderObj.nChannels)

1740

self.systemHeaderObj.nChannels)

1736

1741

1737

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

1742

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

1738

self.processingHeaderObj.profilesPerBlock,

1743

self.processingHeaderObj.profilesPerBlock,

1739

self.processingHeaderObj.nHeights),

1744

self.processingHeaderObj.nHeights),

1740

dtype=numpy.dtype('complex64'))

1745

dtype=numpy.dtype('complex64'))

1741

1746

1742

1747

1743

def writeBlock(self):

1748

def writeBlock(self):

1744

"""

1749

"""

1745

Escribe el buffer en el file designado

1750

Escribe el buffer en el file designado

1746

1751

1747

Affected:

1752

Affected:

1748

self.profileIndex

1753

self.profileIndex

1749

self.flagIsNewFile

1754

self.flagIsNewFile

1750

self.flagIsNewBlock

1755

self.flagIsNewBlock

1751

self.nTotalBlocks

1756

self.nTotalBlocks

1752

self.blockIndex

1757

self.blockIndex

1753

1758

1754

Return: None

1759

Return: None

1755

"""

1760

"""

1756

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

1761

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

1757

1762

1758

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

1763

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

1759

1764

1760

data['real'] = junk.real

1765

data['real'] = junk.real

1761

data['imag'] = junk.imag

1766

data['imag'] = junk.imag

1762

1767

1763

data = data.reshape( (-1) )

1768

data = data.reshape( (-1) )

1764

1769

1765

data.tofile( self.fp )

1770

data.tofile( self.fp )

1766

1771

1767

self.datablock.fill(0)

1772

self.datablock.fill(0)

1768

1773

1769

self.profileIndex = 0

1774

self.profileIndex = 0

1770

self.flagIsNewFile = 0

1775

self.flagIsNewFile = 0

1771

self.flagIsNewBlock = 1

1776

self.flagIsNewBlock = 1

1772

1777

1773

self.blockIndex += 1

1778

self.blockIndex += 1

1774

self.nTotalBlocks += 1

1779

self.nTotalBlocks += 1

1775

1780

1776

def putData(self):

1781

def putData(self):

1777

"""

1782

"""

1778

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

1783

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

1779

1784

1780

Affected:

1785

Affected:

1781

self.flagIsNewBlock

1786

self.flagIsNewBlock

1782

self.profileIndex

1787

self.profileIndex

1783

1788

1784

Return:

1789

Return:

1785

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

1790

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

1786

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

1791

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

1787

"""

1792

"""

1788

if self.dataOut.flagNoData:

1793

if self.dataOut.flagNoData:

1789

return 0

1794

return 0

1790

1795

1791

self.flagIsNewBlock = 0

1796

self.flagIsNewBlock = 0

1792

1797

1793

if self.dataOut.flagTimeBlock:

1798

if self.dataOut.flagTimeBlock:

1794

1799

1795

self.datablock.fill(0)

1800

self.datablock.fill(0)

1796

self.profileIndex = 0

1801

self.profileIndex = 0

1797

self.setNextFile()

1802

self.setNextFile()

1798

1803

1799

if self.profileIndex == 0:

1804

if self.profileIndex == 0:

1800

self.setBasicHeader()

1805

self.setBasicHeader()

1801

1806

1802

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

1807

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

1803

1808

1804

self.profileIndex += 1

1809

self.profileIndex += 1

1805

1810

1806

if self.hasAllDataInBuffer():

1811

if self.hasAllDataInBuffer():

1807

#if self.flagIsNewFile:

1812

#if self.flagIsNewFile:

1808

self.writeNextBlock()

1813

self.writeNextBlock()

1809

# self.setFirstHeader()

1814

# self.setFirstHeader()

1810

1815

1811

return 1

1816

return 1

1812

1817

1813

def __getProcessFlags(self):

1818

def __getProcessFlags(self):

1814

1819

1815

processFlags = 0

1820

processFlags = 0

1816

1821

1817

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

1822

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

1818

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

1823

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

1819

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

1824

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

1820

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

1825

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

1821

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

1826

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

1822

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

1827

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

1823

1828

1824

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

1829

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

1825

1830

1826

1831

1827

1832

1828

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1833

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1829

PROCFLAG.DATATYPE_SHORT,

1834

PROCFLAG.DATATYPE_SHORT,

1830

PROCFLAG.DATATYPE_LONG,

1835

PROCFLAG.DATATYPE_LONG,

1831

PROCFLAG.DATATYPE_INT64,

1836

PROCFLAG.DATATYPE_INT64,

1832

PROCFLAG.DATATYPE_FLOAT,

1837

PROCFLAG.DATATYPE_FLOAT,

1833

PROCFLAG.DATATYPE_DOUBLE]

1838

PROCFLAG.DATATYPE_DOUBLE]

1834

1839

1835

1840

1836

for index in range(len(dtypeList)):

1841

for index in range(len(dtypeList)):

1837

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

1842

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

1838

dtypeValue = datatypeValueList[index]

1843

dtypeValue = datatypeValueList[index]

1839

break

1844

break

1840

1845

1841

processFlags += dtypeValue

1846

processFlags += dtypeValue

1842

1847

1843

if self.dataOut.flagDecodeData:

1848

if self.dataOut.flagDecodeData:

1844

processFlags += PROCFLAG.DECODE_DATA

1849

processFlags += PROCFLAG.DECODE_DATA

1845

1850

1846

if self.dataOut.flagDeflipData:

1851

if self.dataOut.flagDeflipData:

1847

processFlags += PROCFLAG.DEFLIP_DATA

1852

processFlags += PROCFLAG.DEFLIP_DATA

1848

1853

1849

if self.dataOut.code != None:

1854

if self.dataOut.code != None:

1850

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1855

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1851

1856

1852

if self.dataOut.nCohInt > 1:

1857

if self.dataOut.nCohInt > 1:

1853

processFlags += PROCFLAG.COHERENT_INTEGRATION

1858

processFlags += PROCFLAG.COHERENT_INTEGRATION

1854

1859

1855

return processFlags

1860

return processFlags

1856

1861

1857

1862

1858

def __getBlockSize(self):

1863

def __getBlockSize(self):

1859

'''

1864

'''

1860

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

1865

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

1861

'''

1866

'''

1862

1867

1863

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

1868

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

1864

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

1869

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

1865

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

1870

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

1866

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

1871

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

1867

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

1872

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

1868

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

1873

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

1869

1874

1870

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

1875

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

1871

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

1876

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

1872

for index in range(len(dtypeList)):

1877

for index in range(len(dtypeList)):

1873

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

1878

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

1874

datatypeValue = datatypeValueList[index]

1879

datatypeValue = datatypeValueList[index]

1875

break

1880

break

1876

1881

1877

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

1882

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

1878

1883

1879

return blocksize

1884

return blocksize

1880

1885

1881

def setFirstHeader(self):

1886

def setFirstHeader(self):

1882

1887

1883

"""

1888

"""

1884

Obtiene una copia del First Header

1889

Obtiene una copia del First Header

1885

1890

1886

Affected:

1891

Affected:

1887

self.systemHeaderObj

1892

self.systemHeaderObj

1888

self.radarControllerHeaderObj

1893

self.radarControllerHeaderObj

1889

self.dtype

1894

self.dtype

1890

1895

1891

Return:

1896

Return:

1892

None

1897

None

1893

"""

1898

"""

1894

1899

1895

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

1900

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

1896

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1901

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1897

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

1902

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

1898

1903

1899

self.setBasicHeader()

1904

self.setBasicHeader()

1900

1905

1901

processingHeaderSize = 40 # bytes

1906

processingHeaderSize = 40 # bytes

1902

self.processingHeaderObj.dtype = 0 # Voltage

1907

self.processingHeaderObj.dtype = 0 # Voltage

1903

self.processingHeaderObj.blockSize = self.__getBlockSize()

1908

self.processingHeaderObj.blockSize = self.__getBlockSize()

1904

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1909

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1905

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1910

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1906

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

1911

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

1907

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1912

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1908

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1913

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1909

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

1914

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

1910

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

1915

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

1911

1916

1912

# if self.dataOut.code != None:

1917

# if self.dataOut.code != None:

1913

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

1918

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

1914

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

1919

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

1915

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

1920

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

1916

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

1921

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

1917

# processingHeaderSize += codesize

1922

# processingHeaderSize += codesize

1918

1923

1919

if self.processingHeaderObj.nWindows != 0:

1924

if self.processingHeaderObj.nWindows != 0:

1920

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

1925

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

1921

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

1926

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

1922

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1927

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1923

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1928

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1924

processingHeaderSize += 12

1929

processingHeaderSize += 12

1925

1930

1926

self.processingHeaderObj.size = processingHeaderSize

1931

self.processingHeaderObj.size = processingHeaderSize

1927

1932

1928

class SpectraReader(JRODataReader):

1933

class SpectraReader(JRODataReader):

1929

"""

1934

"""

1930

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

1935

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

1931

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

1936

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

1932

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

1937

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

1933

1938

1934

paresCanalesIguales * alturas * perfiles (Self Spectra)

1939

paresCanalesIguales * alturas * perfiles (Self Spectra)

1935

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1940

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1936

canales * alturas (DC Channels)

1941

canales * alturas (DC Channels)

1937

1942

1938

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

1943

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

1939

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

1944

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

1940

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

1945

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

1941

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

1946

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

1942

1947

1943

Example:

1948

Example:

1944

dpath = "/home/myuser/data"

1949

dpath = "/home/myuser/data"

1945

1950

1946

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

1951

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

1947

1952

1948

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

1953

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

1949

1954

1950

readerObj = SpectraReader()

1955

readerObj = SpectraReader()

1951

1956

1952

readerObj.setup(dpath, startTime, endTime)

1957

readerObj.setup(dpath, startTime, endTime)

1953

1958

1954

while(True):

1959

while(True):

1955

1960

1956

readerObj.getData()

1961

readerObj.getData()

1957

1962

1958

print readerObj.data_spc

1963

print readerObj.data_spc

1959

1964

1960

print readerObj.data_cspc

1965

print readerObj.data_cspc

1961

1966

1962

print readerObj.data_dc

1967

print readerObj.data_dc

1963

1968

1964

if readerObj.flagNoMoreFiles:

1969

if readerObj.flagNoMoreFiles:

1965

break

1970

break

1966

1971

1967

"""

1972

"""

1968

1973

1969

pts2read_SelfSpectra = 0

1974

pts2read_SelfSpectra = 0

1970

1975

1971

pts2read_CrossSpectra = 0

1976

pts2read_CrossSpectra = 0

1972

1977

1973

pts2read_DCchannels = 0

1978

pts2read_DCchannels = 0

1974

1979

1975

ext = ".pdata"

1980

ext = ".pdata"

1976

1981

1977

optchar = "P"

1982

optchar = "P"

1978

1983

1979

dataOut = None

1984

dataOut = None

1980

1985

1981

nRdChannels = None

1986

nRdChannels = None

1982

1987

1983

nRdPairs = None

1988

nRdPairs = None

1984

1989

1985

rdPairList = []

1990

rdPairList = []

1986

1991

1987

def __init__(self):

1992

def __init__(self):

1988

"""

1993

"""

1989

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

1994

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

1990

1995

1991

Inputs:

1996

Inputs:

1992

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

1997

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

1993

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

1998

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

1994

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

1999

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

1995

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

2000

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

1996

bloque de datos.

2001

bloque de datos.

1997

Si este parametro no es pasado se creara uno internamente.

2002

Si este parametro no es pasado se creara uno internamente.

1998

2003

1999

Affected:

2004

Affected:

2000

self.dataOut

2005

self.dataOut

2001

2006

2002

Return : None

2007

Return : None

2003

"""

2008

"""

2004

2009

2005

self.isConfig = False

2010

self.isConfig = False

2006

2011

2007

self.pts2read_SelfSpectra = 0

2012

self.pts2read_SelfSpectra = 0

2008

2013

2009

self.pts2read_CrossSpectra = 0

2014

self.pts2read_CrossSpectra = 0

2010

2015

2011

self.pts2read_DCchannels = 0

2016

self.pts2read_DCchannels = 0

2012

2017

2013

self.datablock = None

2018

self.datablock = None

2014

2019

2015

self.utc = None

2020

self.utc = None

2016

2021

2017

self.ext = ".pdata"

2022

self.ext = ".pdata"

2018

2023

2019

self.optchar = "P"

2024

self.optchar = "P"

2020

2025

2021

self.basicHeaderObj = BasicHeader(LOCALTIME)

2026

self.basicHeaderObj = BasicHeader(LOCALTIME)

2022

2027

2023

self.systemHeaderObj = SystemHeader()

2028

self.systemHeaderObj = SystemHeader()

2024

2029

2025

self.radarControllerHeaderObj = RadarControllerHeader()

2030

self.radarControllerHeaderObj = RadarControllerHeader()

2026

2031

2027

self.processingHeaderObj = ProcessingHeader()

2032

self.processingHeaderObj = ProcessingHeader()

2028

2033

2029

self.online = 0

2034

self.online = 0

2030

2035

2031

self.fp = None

2036

self.fp = None

2032

2037

2033

self.idFile = None

2038

self.idFile = None

2034

2039

2035

self.dtype = None

2040

self.dtype = None

2036

2041

2037

self.fileSizeByHeader = None

2042

self.fileSizeByHeader = None

2038

2043

2039

self.filenameList = []

2044

self.filenameList = []

2040

2045

2041

self.filename = None

2046

self.filename = None

2042

2047

2043

self.fileSize = None

2048

self.fileSize = None

2044

2049

2045

self.firstHeaderSize = 0

2050

self.firstHeaderSize = 0

2046

2051

2047

self.basicHeaderSize = 24

2052

self.basicHeaderSize = 24

2048

2053

2049

self.pathList = []

2054

self.pathList = []

2050

2055

2051

self.lastUTTime = 0

2056

self.lastUTTime = 0

2052

2057

2053

self.maxTimeStep = 30

2058

self.maxTimeStep = 30

2054

2059

2055

self.flagNoMoreFiles = 0

2060

self.flagNoMoreFiles = 0

2056

2061

2057

self.set = 0

2062

self.set = 0

2058

2063

2059

self.path = None

2064

self.path = None

2060

2065

2061

self.delay = 60 #seconds

2066

self.delay = 60 #seconds

2062

2067

2063

self.nTries = 3 #quantity tries

2068

self.nTries = 3 #quantity tries

2064

2069

2065

self.nFiles = 3 #number of files for searching

2070

self.nFiles = 3 #number of files for searching

2066

2071

2067

self.nReadBlocks = 0

2072

self.nReadBlocks = 0

2068

2073

2069

self.flagIsNewFile = 1

2074

self.flagIsNewFile = 1

2070

2075

2071

self.__isFirstTimeOnline = 1

2076

self.__isFirstTimeOnline = 1

2072

2077

2073

self.ippSeconds = 0

2078

self.ippSeconds = 0

2074

2079

2075

self.flagTimeBlock = 0

2080

self.flagTimeBlock = 0

2076

2081

2077

self.flagIsNewBlock = 0

2082

self.flagIsNewBlock = 0

2078

2083

2079

self.nTotalBlocks = 0

2084

self.nTotalBlocks = 0

2080

2085

2081

self.blocksize = 0

2086

self.blocksize = 0

2082

2087

2083

self.dataOut = self.createObjByDefault()

2088

self.dataOut = self.createObjByDefault()

2084

2089

2085

self.profileIndex = 1 #Always

2090

self.profileIndex = 1 #Always

2086

2091

2087

2092

2088

def createObjByDefault(self):

2093

def createObjByDefault(self):

2089

2094

2090

dataObj = Spectra()

2095

dataObj = Spectra()

2091

2096

2092

return dataObj

2097

return dataObj

2093

2098

2094

def __hasNotDataInBuffer(self):

2099

def __hasNotDataInBuffer(self):

2095

return 1

2100

return 1

2096

2101

2097

2102

2098

def getBlockDimension(self):

2103

def getBlockDimension(self):

2099

"""

2104

"""

2100

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

2105

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

2101

2106

2102

Affected:

2107

Affected:

2103

self.nRdChannels

2108

self.nRdChannels

2104

self.nRdPairs

2109

self.nRdPairs

2105

self.pts2read_SelfSpectra

2110

self.pts2read_SelfSpectra

2106

self.pts2read_CrossSpectra

2111

self.pts2read_CrossSpectra

2107

self.pts2read_DCchannels

2112

self.pts2read_DCchannels

2108

self.blocksize

2113

self.blocksize

2109

self.dataOut.nChannels

2114

self.dataOut.nChannels

2110

self.dataOut.nPairs

2115

self.dataOut.nPairs

2111

2116

2112

Return:

2117

Return:

2113

None

2118

None

2114

"""

2119

"""

2115

self.nRdChannels = 0

2120

self.nRdChannels = 0

2116

self.nRdPairs = 0

2121

self.nRdPairs = 0

2117

self.rdPairList = []

2122

self.rdPairList = []

2118

2123

2119

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

2124

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

2120

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

2125

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

2121

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

2126

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

2122

else:

2127

else:

2123

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

2128

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

2124

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

2129

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

2125

2130

2126

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

2131

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

2127

2132

2128

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

2133

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

2129

self.blocksize = self.pts2read_SelfSpectra

2134

self.blocksize = self.pts2read_SelfSpectra

2130

2135

2131

if self.processingHeaderObj.flag_cspc:

2136

if self.processingHeaderObj.flag_cspc:

2132

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

2137

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

2133

self.blocksize += self.pts2read_CrossSpectra

2138

self.blocksize += self.pts2read_CrossSpectra

2134

2139

2135

if self.processingHeaderObj.flag_dc:

2140

if self.processingHeaderObj.flag_dc:

2136

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

2141

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

2137

self.blocksize += self.pts2read_DCchannels

2142

self.blocksize += self.pts2read_DCchannels

2138

2143

2139

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

2144

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

2140

2145

2141

2146

2142

def readBlock(self):

2147

def readBlock(self):

2143

"""

2148

"""

2144

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

2149

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

2145

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

2150

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

2146

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

2151

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

2147

es seteado a 0

2152

es seteado a 0

2148

2153

2149

Return: None

2154

Return: None

2150

2155

2151

Variables afectadas:

2156

Variables afectadas:

2152

2157

2153

self.flagIsNewFile

2158

self.flagIsNewFile

2154

self.flagIsNewBlock

2159

self.flagIsNewBlock

2155

self.nTotalBlocks

2160

self.nTotalBlocks

2156

self.data_spc

2161

self.data_spc

2157

self.data_cspc

2162

self.data_cspc

2158

self.data_dc

2163

self.data_dc

2159

2164

2160

Exceptions:

2165

Exceptions:

2161

Si un bloque leido no es un bloque valido

2166

Si un bloque leido no es un bloque valido

2162

"""

2167

"""

2163

blockOk_flag = False

2168

blockOk_flag = False

2164

fpointer = self.fp.tell()

2169

fpointer = self.fp.tell()

2165

2170

2166

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

2171

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

2167

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

2172

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

2168

2173

2169

if self.processingHeaderObj.flag_cspc:

2174

if self.processingHeaderObj.flag_cspc:

2170

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

2175

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

2171

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

2176

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

2172

2177

2173

if self.processingHeaderObj.flag_dc:

2178

if self.processingHeaderObj.flag_dc:

2174

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

2179

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

2175

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

2180

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

2176

2181

2177

2182

2178

if not(self.processingHeaderObj.shif_fft):

2183

if not(self.processingHeaderObj.shif_fft):

2179

#desplaza a la derecha en el eje 2 determinadas posiciones

2184

#desplaza a la derecha en el eje 2 determinadas posiciones

2180

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

2185

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

2181

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

2186

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

2182

2187

2183

if self.processingHeaderObj.flag_cspc:

2188

if self.processingHeaderObj.flag_cspc:

2184

#desplaza a la derecha en el eje 2 determinadas posiciones

2189

#desplaza a la derecha en el eje 2 determinadas posiciones

2185

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

2190

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

2186

2191

2187

# self.processingHeaderObj.shif_fft = True

2192

# self.processingHeaderObj.shif_fft = True

2188

2193

2189

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

2194

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

2190

self.data_spc = spc

2195

self.data_spc = spc

2191

2196

2192

if self.processingHeaderObj.flag_cspc:

2197

if self.processingHeaderObj.flag_cspc:

2193

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

2198

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

2194

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

2199

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

2195

else:

2200

else:

2196

self.data_cspc = None

2201

self.data_cspc = None

2197

2202

2198

if self.processingHeaderObj.flag_dc:

2203

if self.processingHeaderObj.flag_dc:

2199

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

2204

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

2200

else:

2205

else:

2201

self.data_dc = None

2206

self.data_dc = None

2202

2207

2203

self.flagIsNewFile = 0

2208

self.flagIsNewFile = 0

2204

self.flagIsNewBlock = 1

2209

self.flagIsNewBlock = 1

2205

2210

2206

self.nTotalBlocks += 1

2211

self.nTotalBlocks += 1

2207

self.nReadBlocks += 1

2212

self.nReadBlocks += 1

2208

2213

2209

return 1

2214

return 1

2210

2215

2211

def getFirstHeader(self):

2216

def getFirstHeader(self):

2212

2217

2213

self.dataOut.dtype = self.dtype

2218

self.dataOut.dtype = self.dtype

2214

2219

2215

self.dataOut.nPairs = self.nRdPairs

2220

self.dataOut.nPairs = self.nRdPairs

2216

2221

2217

self.dataOut.pairsList = self.rdPairList

2222

self.dataOut.pairsList = self.rdPairList

2218

2223

2219

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2224

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2220

2225

2221

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2226

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2222

2227

2223

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2228

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2224

2229

2225

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2230

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2226

2231

2227

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

2232

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

2228

2233

2229

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

2234

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

2230

2235

2231

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

2236

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

2232

2237

2233

self.dataOut.ippSeconds = self.ippSeconds

2238

self.dataOut.ippSeconds = self.ippSeconds

2234

2239

2235

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

2240

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

2236

2241

2237

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

2242

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

2238

2243

2239

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

2244

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

2240

2245

2241

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2246

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2242

2247

2243

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

2248

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

2244

2249

2245

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

2250

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

2246

2251

2247

if self.processingHeaderObj.code != None:

2252

if self.processingHeaderObj.code != None:

2248

2253

2249

self.dataOut.nCode = self.processingHeaderObj.nCode

2254

self.dataOut.nCode = self.processingHeaderObj.nCode

2250

2255

2251

self.dataOut.nBaud = self.processingHeaderObj.nBaud

2256

self.dataOut.nBaud = self.processingHeaderObj.nBaud

2252

2257

2253

self.dataOut.code = self.processingHeaderObj.code

2258

self.dataOut.code = self.processingHeaderObj.code

2254

2259

2255

self.dataOut.flagDecodeData = True

2260

self.dataOut.flagDecodeData = True

2256

2261

2257

def getData(self):

2262

def getData(self):

2258

"""

2263

"""

2259

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

2264

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

2260

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

2265

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

2261

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

2266

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

2262

2267

2263

Return:

2268

Return:

2264

0 : Si no hay mas archivos disponibles

2269

0 : Si no hay mas archivos disponibles

2265

1 : Si hizo una buena copia del buffer

2270

1 : Si hizo una buena copia del buffer

2266

2271

2267

Affected:

2272

Affected:

2268

self.dataOut

2273

self.dataOut

2269

2274

2270

self.flagTimeBlock

2275

self.flagTimeBlock

2271

self.flagIsNewBlock

2276

self.flagIsNewBlock

2272

"""

2277

"""

2273

2278

2274

if self.flagNoMoreFiles:

2279

if self.flagNoMoreFiles:

2275

self.dataOut.flagNoData = True

2280

self.dataOut.flagNoData = True

2276

print 'Process finished'

2281

print 'Process finished'

2277

return 0

2282

return 0

2278

2283

2279

self.flagTimeBlock = 0

2284

self.flagTimeBlock = 0

2280

self.flagIsNewBlock = 0

2285

self.flagIsNewBlock = 0

2281

2286

2282

if self.__hasNotDataInBuffer():

2287

if self.__hasNotDataInBuffer():

2283

2288

2284

if not( self.readNextBlock() ):

2289

if not( self.readNextBlock() ):

2285

self.dataOut.flagNoData = True

2290

self.dataOut.flagNoData = True

2286

return 0

2291

return 0

2287

2292

2288

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

2293

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

2289

2294

2290

if self.data_dc == None:

2295

if self.data_dc == None:

2291

self.dataOut.flagNoData = True

2296

self.dataOut.flagNoData = True

2292

return 0

2297

return 0

2293

2298

2294

self.getBasicHeader()

2299

self.getBasicHeader()

2295

2300

2296

self.getFirstHeader()

2301

self.getFirstHeader()

2297

2302

2298

self.dataOut.data_spc = self.data_spc

2303

self.dataOut.data_spc = self.data_spc

2299

2304

2300

self.dataOut.data_cspc = self.data_cspc

2305

self.dataOut.data_cspc = self.data_cspc

2301

2306

2302

self.dataOut.data_dc = self.data_dc

2307

self.dataOut.data_dc = self.data_dc

2303

2308

2304

self.dataOut.flagNoData = False

2309

self.dataOut.flagNoData = False

2305

2310

2306

self.dataOut.realtime = self.online

2311

self.dataOut.realtime = self.online

2307

2312

2308

return self.dataOut.data_spc

2313

return self.dataOut.data_spc

2309

2314

2310

2315

2311

class SpectraWriter(JRODataWriter):

2316

class SpectraWriter(JRODataWriter):

2312

2317

2313

"""

2318

"""

2314

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

2319

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

2315

de los datos siempre se realiza por bloques.

2320

de los datos siempre se realiza por bloques.

2316

"""

2321

"""

2317

2322

2318

ext = ".pdata"

2323

ext = ".pdata"

2319

2324

2320

optchar = "P"

2325

optchar = "P"

2321

2326

2322

shape_spc_Buffer = None

2327

shape_spc_Buffer = None

2323

2328

2324

shape_cspc_Buffer = None

2329

shape_cspc_Buffer = None

2325

2330

2326

shape_dc_Buffer = None

2331

shape_dc_Buffer = None

2327

2332

2328

data_spc = None

2333

data_spc = None

2329

2334

2330

data_cspc = None

2335

data_cspc = None

2331

2336

2332

data_dc = None

2337

data_dc = None

2333

2338

2334

# dataOut = None

2339

# dataOut = None

2335

2340

2336

def __init__(self):

2341

def __init__(self):

2337

"""

2342

"""

2338

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

2343

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

2339

2344

2340

Affected:

2345

Affected:

2341

self.dataOut

2346

self.dataOut

2342

self.basicHeaderObj

2347

self.basicHeaderObj

2343

self.systemHeaderObj

2348

self.systemHeaderObj

2344

self.radarControllerHeaderObj

2349

self.radarControllerHeaderObj

2345

self.processingHeaderObj

2350

self.processingHeaderObj

2346

2351

2347

Return: None

2352

Return: None

2348

"""

2353

"""

2349

2354

2350

self.isConfig = False

2355

self.isConfig = False

2351

2356

2352

self.nTotalBlocks = 0

2357

self.nTotalBlocks = 0

2353

2358

2354

self.data_spc = None

2359

self.data_spc = None

2355

2360

2356

self.data_cspc = None

2361

self.data_cspc = None

2357

2362

2358

self.data_dc = None

2363

self.data_dc = None

2359

2364

2360

self.fp = None

2365

self.fp = None

2361

2366

2362

self.flagIsNewFile = 1

2367

self.flagIsNewFile = 1

2363

2368

2364

self.nTotalBlocks = 0

2369

self.nTotalBlocks = 0

2365

2370

2366

self.flagIsNewBlock = 0

2371

self.flagIsNewBlock = 0

2367

2372

2368

self.setFile = None

2373

self.setFile = None

2369

2374

2370

self.dtype = None

2375

self.dtype = None

2371

2376

2372

self.path = None

2377

self.path = None

2373

2378

2374

self.noMoreFiles = 0

2379

self.noMoreFiles = 0

2375

2380

2376

self.filename = None

2381

self.filename = None

2377

2382

2378

self.basicHeaderObj = BasicHeader(LOCALTIME)

2383

self.basicHeaderObj = BasicHeader(LOCALTIME)

2379

2384

2380

self.systemHeaderObj = SystemHeader()

2385

self.systemHeaderObj = SystemHeader()

2381

2386

2382

self.radarControllerHeaderObj = RadarControllerHeader()

2387

self.radarControllerHeaderObj = RadarControllerHeader()

2383

2388

2384

self.processingHeaderObj = ProcessingHeader()

2389

self.processingHeaderObj = ProcessingHeader()

2385

2390

2386

2391

2387

def hasAllDataInBuffer(self):

2392

def hasAllDataInBuffer(self):

2388

return 1

2393

return 1

2389

2394

2390

2395

2391

def setBlockDimension(self):

2396

def setBlockDimension(self):

2392

"""

2397

"""

2393

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

2398

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

2394

2399

2395

Affected:

2400

Affected:

2396

self.shape_spc_Buffer

2401

self.shape_spc_Buffer

2397

self.shape_cspc_Buffer

2402

self.shape_cspc_Buffer

2398

self.shape_dc_Buffer

2403

self.shape_dc_Buffer

2399

2404

2400

Return: None

2405

Return: None

2401

"""

2406

"""

2402

self.shape_spc_Buffer = (self.dataOut.nChannels,

2407

self.shape_spc_Buffer = (self.dataOut.nChannels,

2403

self.processingHeaderObj.nHeights,

2408

self.processingHeaderObj.nHeights,

2404

self.processingHeaderObj.profilesPerBlock)

2409

self.processingHeaderObj.profilesPerBlock)

2405

2410

2406

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2411

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2407

self.processingHeaderObj.nHeights,

2412

self.processingHeaderObj.nHeights,

2408

self.processingHeaderObj.profilesPerBlock)

2413

self.processingHeaderObj.profilesPerBlock)

2409

2414

2410

self.shape_dc_Buffer = (self.dataOut.nChannels,

2415

self.shape_dc_Buffer = (self.dataOut.nChannels,

2411

self.processingHeaderObj.nHeights)

2416

self.processingHeaderObj.nHeights)

2412

2417

2413

2418

2414

def writeBlock(self):

2419

def writeBlock(self):

2415

"""

2420

"""

2416

Escribe el buffer en el file designado

2421

Escribe el buffer en el file designado

2417

2422

2418

Affected:

2423

Affected:

2419

self.data_spc

2424

self.data_spc

2420

self.data_cspc

2425

self.data_cspc

2421

self.data_dc

2426

self.data_dc

2422

self.flagIsNewFile

2427

self.flagIsNewFile

2423

self.flagIsNewBlock

2428

self.flagIsNewBlock

2424

self.nTotalBlocks

2429

self.nTotalBlocks

2425

self.nWriteBlocks

2430

self.nWriteBlocks

2426

2431

2427

Return: None

2432

Return: None

2428

"""

2433

"""

2429

2434

2430

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

2435

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

2431

if not( self.processingHeaderObj.shif_fft ):

2436

if not( self.processingHeaderObj.shif_fft ):

2432

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

2437

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

2433

data = spc.reshape((-1))

2438

data = spc.reshape((-1))

2434

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

2439

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

2435

data.tofile(self.fp)

2440

data.tofile(self.fp)

2436

2441

2437

if self.data_cspc != None:

2442

if self.data_cspc != None:

2438

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

2443

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

2439

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

2444

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

2440

if not( self.processingHeaderObj.shif_fft ):

2445

if not( self.processingHeaderObj.shif_fft ):

2441

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

2446

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

2442

data['real'] = cspc.real

2447

data['real'] = cspc.real

2443

data['imag'] = cspc.imag

2448

data['imag'] = cspc.imag

2444

data = data.reshape((-1))

2449

data = data.reshape((-1))

2445

data.tofile(self.fp)

2450

data.tofile(self.fp)

2446

2451

2447

if self.data_dc != None:

2452

if self.data_dc != None:

2448

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

2453

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

2449

dc = self.data_dc

2454

dc = self.data_dc

2450

data['real'] = dc.real

2455

data['real'] = dc.real

2451

data['imag'] = dc.imag

2456

data['imag'] = dc.imag

2452

data = data.reshape((-1))

2457

data = data.reshape((-1))

2453

data.tofile(self.fp)

2458

data.tofile(self.fp)

2454

2459

2455

self.data_spc.fill(0)

2460

self.data_spc.fill(0)

2456

2461

2457

if self.data_dc != None:

2462

if self.data_dc != None:

2458

self.data_dc.fill(0)

2463

self.data_dc.fill(0)

2459

2464

2460

if self.data_cspc != None:

2465

if self.data_cspc != None:

2461

self.data_cspc.fill(0)

2466

self.data_cspc.fill(0)

2462

2467

2463

self.flagIsNewFile = 0

2468

self.flagIsNewFile = 0

2464

self.flagIsNewBlock = 1

2469

self.flagIsNewBlock = 1

2465

self.nTotalBlocks += 1

2470

self.nTotalBlocks += 1

2466

self.nWriteBlocks += 1

2471

self.nWriteBlocks += 1

2467

self.blockIndex += 1

2472

self.blockIndex += 1

2468

2473

2469

2474

2470

def putData(self):

2475

def putData(self):

2471

"""

2476

"""

2472

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

2477

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

2473

2478

2474

Affected:

2479

Affected:

2475

self.data_spc

2480

self.data_spc

2476

self.data_cspc

2481

self.data_cspc

2477

self.data_dc

2482

self.data_dc

2478

2483

2479

Return:

2484

Return:

2480

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

2485

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

2481

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

2486

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

2482

"""

2487

"""

2483

2488

2484

if self.dataOut.flagNoData:

2489

if self.dataOut.flagNoData:

2485

return 0

2490

return 0

2486

2491

2487

self.flagIsNewBlock = 0

2492

self.flagIsNewBlock = 0

2488

2493

2489

if self.dataOut.flagTimeBlock:

2494

if self.dataOut.flagTimeBlock:

2490

self.data_spc.fill(0)

2495

self.data_spc.fill(0)

2491

self.data_cspc.fill(0)

2496

self.data_cspc.fill(0)

2492

self.data_dc.fill(0)

2497

self.data_dc.fill(0)

2493

self.setNextFile()

2498

self.setNextFile()

2494

2499

2495

if self.flagIsNewFile == 0:

2500

if self.flagIsNewFile == 0:

2496

self.setBasicHeader()

2501

self.setBasicHeader()

2497

2502

2498

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

2503

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

2499

if self.dataOut.data_cspc != None:

2504

if self.dataOut.data_cspc != None:

2500

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

2505

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

2501

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

2506

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

2502

2507

2503

# #self.processingHeaderObj.dataBlocksPerFile)

2508

# #self.processingHeaderObj.dataBlocksPerFile)

2504

if self.hasAllDataInBuffer():

2509

if self.hasAllDataInBuffer():

2505

# self.setFirstHeader()

2510

# self.setFirstHeader()

2506

self.writeNextBlock()

2511

self.writeNextBlock()

2507

2512

2508

return 1

2513

return 1

2509

2514

2510

2515

2511

def __getProcessFlags(self):

2516

def __getProcessFlags(self):

2512

2517

2513

processFlags = 0

2518

processFlags = 0

2514

2519

2515

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

2520

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

2516

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

2521

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

2517

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

2522

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

2518

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

2523

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

2519

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

2524

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

2520

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

2525

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

2521

2526

2522

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

2527

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

2523

2528

2524

2529

2525

2530

2526

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2531

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2527

PROCFLAG.DATATYPE_SHORT,

2532

PROCFLAG.DATATYPE_SHORT,

2528

PROCFLAG.DATATYPE_LONG,

2533

PROCFLAG.DATATYPE_LONG,

2529

PROCFLAG.DATATYPE_INT64,

2534

PROCFLAG.DATATYPE_INT64,

2530

PROCFLAG.DATATYPE_FLOAT,

2535

PROCFLAG.DATATYPE_FLOAT,

2531

PROCFLAG.DATATYPE_DOUBLE]

2536

PROCFLAG.DATATYPE_DOUBLE]

2532

2537

2533

2538

2534

for index in range(len(dtypeList)):

2539

for index in range(len(dtypeList)):

2535

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

2540

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

2536

dtypeValue = datatypeValueList[index]

2541

dtypeValue = datatypeValueList[index]

2537

break

2542

break

2538

2543

2539

processFlags += dtypeValue

2544

processFlags += dtypeValue

2540

2545

2541

if self.dataOut.flagDecodeData:

2546

if self.dataOut.flagDecodeData:

2542

processFlags += PROCFLAG.DECODE_DATA

2547

processFlags += PROCFLAG.DECODE_DATA

2543

2548

2544

if self.dataOut.flagDeflipData:

2549

if self.dataOut.flagDeflipData:

2545

processFlags += PROCFLAG.DEFLIP_DATA

2550

processFlags += PROCFLAG.DEFLIP_DATA

2546

2551

2547

if self.dataOut.code != None:

2552

if self.dataOut.code != None:

2548

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2553

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2549

2554

2550

if self.dataOut.nIncohInt > 1:

2555

if self.dataOut.nIncohInt > 1:

2551

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2556

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2552

2557

2553

if self.dataOut.data_dc != None:

2558

if self.dataOut.data_dc != None:

2554

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2559

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2555

2560

2556

return processFlags

2561

return processFlags

2557

2562

2558

2563

2559

def __getBlockSize(self):

2564

def __getBlockSize(self):

2560

'''

2565

'''

2561

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

2566

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

2562

'''

2567

'''

2563

2568

2564

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

2569

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

2565

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

2570

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

2566

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

2571

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

2567

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

2572

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

2568

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

2573

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

2569

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

2574

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

2570

2575

2571

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

2576

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

2572

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

2577

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

2573

for index in range(len(dtypeList)):

2578

for index in range(len(dtypeList)):

2574

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

2579

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

2575

datatypeValue = datatypeValueList[index]

2580

datatypeValue = datatypeValueList[index]

2576

break

2581

break

2577

2582

2578

2583

2579

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

2584

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

2580

2585

2581

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

2586

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

2582

blocksize = (pts2write_SelfSpectra*datatypeValue)

2587

blocksize = (pts2write_SelfSpectra*datatypeValue)

2583

2588

2584

if self.dataOut.data_cspc != None:

2589

if self.dataOut.data_cspc != None:

2585

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

2590

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

2586

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2591

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2587

2592

2588

if self.dataOut.data_dc != None:

2593

if self.dataOut.data_dc != None:

2589

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

2594

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

2590

blocksize += (pts2write_DCchannels*datatypeValue*2)

2595

blocksize += (pts2write_DCchannels*datatypeValue*2)

2591

2596

2592

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2597

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2593

2598

2594

return blocksize

2599

return blocksize

2595

2600

2596

def setFirstHeader(self):

2601

def setFirstHeader(self):

2597

2602

2598

"""

2603

"""

2599

Obtiene una copia del First Header

2604

Obtiene una copia del First Header

2600

2605

2601

Affected:

2606

Affected:

2602

self.systemHeaderObj

2607

self.systemHeaderObj

2603

self.radarControllerHeaderObj

2608

self.radarControllerHeaderObj

2604

self.dtype

2609

self.dtype

2605

2610

2606

Return:

2611

Return:

2607

None

2612

None

2608

"""

2613

"""

2609

2614

2610

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

2615

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

2611

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2616

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2612

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

2617

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

2613

2618

2614

self.setBasicHeader()

2619

self.setBasicHeader()

2615

2620

2616

processingHeaderSize = 40 # bytes

2621

processingHeaderSize = 40 # bytes

2617

self.processingHeaderObj.dtype = 1 # Spectra

2622

self.processingHeaderObj.dtype = 1 # Spectra

2618

self.processingHeaderObj.blockSize = self.__getBlockSize()

2623

self.processingHeaderObj.blockSize = self.__getBlockSize()

2619

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2624

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2620

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2625

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2621

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

2626

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

2622

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2627

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2623

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

2628

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

2624

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2629

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2625

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

2630

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

2626

self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT

2631

self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT

2627

2632

2628

if self.processingHeaderObj.totalSpectra > 0:

2633

if self.processingHeaderObj.totalSpectra > 0:

2629

channelList = []

2634

channelList = []

2630

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

2635

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

2631

channelList.append(channel)

2636

channelList.append(channel)

2632

channelList.append(channel)

2637

channelList.append(channel)

2633

2638

2634

pairsList = []

2639

pairsList = []

2635

if self.dataOut.nPairs > 0:

2640

if self.dataOut.nPairs > 0:

2636

for pair in self.dataOut.pairsList:

2641

for pair in self.dataOut.pairsList:

2637

pairsList.append(pair[0])

2642

pairsList.append(pair[0])

2638

pairsList.append(pair[1])

2643

pairsList.append(pair[1])

2639

2644

2640

spectraComb = channelList + pairsList

2645

spectraComb = channelList + pairsList

2641

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

2646

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

2642

self.processingHeaderObj.spectraComb = spectraComb

2647

self.processingHeaderObj.spectraComb = spectraComb

2643

sizeOfSpcComb = len(spectraComb)

2648

sizeOfSpcComb = len(spectraComb)

2644

processingHeaderSize += sizeOfSpcComb

2649

processingHeaderSize += sizeOfSpcComb

2645

2650

2646

# The processing header should not have information about code

2651

# The processing header should not have information about code

2647

# if self.dataOut.code != None:

2652

# if self.dataOut.code != None:

2648

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

2653

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

2649

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

2654

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

2650

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

2655

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

2651

# nCodeSize = 4 # bytes

2656

# nCodeSize = 4 # bytes

2652

# nBaudSize = 4 # bytes

2657

# nBaudSize = 4 # bytes

2653

# codeSize = 4 # bytes

2658

# codeSize = 4 # bytes

2654

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

2659

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

2655

# processingHeaderSize += sizeOfCode

2660

# processingHeaderSize += sizeOfCode

2656

2661

2657

if self.processingHeaderObj.nWindows != 0:

2662

if self.processingHeaderObj.nWindows != 0:

2658

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

2663

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

2659

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

2664

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

2660

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2665

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2661

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2666

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2662

sizeOfFirstHeight = 4

2667

sizeOfFirstHeight = 4

2663

sizeOfdeltaHeight = 4

2668

sizeOfdeltaHeight = 4

2664

sizeOfnHeights = 4

2669

sizeOfnHeights = 4

2665

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

2670

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

2666

processingHeaderSize += sizeOfWindows

2671

processingHeaderSize += sizeOfWindows

2667

2672

2668

self.processingHeaderObj.size = processingHeaderSize

2673

self.processingHeaderObj.size = processingHeaderSize

2669

2674

2670

class SpectraHeisWriter(Operation):

2675

class SpectraHeisWriter(Operation):

2671

# set = None

2676

# set = None

2672

setFile = None

2677

setFile = None

2673

idblock = None

2678

idblock = None

2674

doypath = None

2679

doypath = None

2675

subfolder = None

2680

subfolder = None

2676

2681

2677

def __init__(self):

2682

def __init__(self):

2678

self.wrObj = FITS()

2683

self.wrObj = FITS()

2679

# self.dataOut = dataOut

2684

# self.dataOut = dataOut

2680

self.nTotalBlocks=0

2685

self.nTotalBlocks=0

2681

# self.set = None

2686

# self.set = None

2682

self.setFile = None

2687

self.setFile = None

2683

self.idblock = 0

2688

self.idblock = 0

2684

self.wrpath = None

2689

self.wrpath = None

2685

self.doypath = None

2690

self.doypath = None

2686

self.subfolder = None

2691

self.subfolder = None

2687

self.isConfig = False

2692

self.isConfig = False

2688

2693

2689

def isNumber(str):

2694

def isNumber(str):

2690

"""

2695

"""

2691

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

2696

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

2692

2697

2693

Excepciones:

2698

Excepciones:

2694

Si un determinado string no puede ser convertido a numero

2699

Si un determinado string no puede ser convertido a numero

2695

Input:

2700

Input:

2696

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

2701

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

2697

2702

2698

Return:

2703

Return:

2699

True : si el string es uno numerico

2704

True : si el string es uno numerico

2700

False : no es un string numerico

2705

False : no es un string numerico

2701

"""

2706

"""

2702

try:

2707

try:

2703

float( str )

2708

float( str )

2704

return True

2709

return True

2705

except:

2710

except:

2706

return False

2711

return False

2707

2712

2708

def setup(self, dataOut, wrpath):

2713

def setup(self, dataOut, wrpath):

2709

2714

2710

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

2715

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

2711

os.mkdir(wrpath)

2716

os.mkdir(wrpath)

2712

2717

2713

self.wrpath = wrpath

2718

self.wrpath = wrpath

2714

# self.setFile = 0

2719

# self.setFile = 0

2715

self.dataOut = dataOut

2720

self.dataOut = dataOut

2716

2721

2717

def putData(self):

2722

def putData(self):

2718

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

2723

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

2719

ext=".fits"

2724

ext=".fits"

2720

2725

2721

if self.doypath == None:

2726

if self.doypath == None:

2722

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

2727

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

2723

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

2728

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

2724

os.mkdir(self.doypath)

2729

os.mkdir(self.doypath)

2725

2730

2726

if self.setFile == None:

2731

if self.setFile == None:

2727

# self.set = self.dataOut.set

2732

# self.set = self.dataOut.set

2728

self.setFile = 0

2733

self.setFile = 0

2729

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

2734

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

2730

## self.set = self.dataOut.set

2735

## self.set = self.dataOut.set

2731

# self.setFile = 0

2736

# self.setFile = 0

2732

2737

2733

#make the filename

2738

#make the filename

2734

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

2739

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

2735

2740

2736

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

2741

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

2737

2742

2738

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

2743

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

2739

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

2744

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

2740

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

2745

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

2741

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

2746

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

2742

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

2747

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

2743

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

2748

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

2744

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

2749

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

2745

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

2750

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

2746

2751

2747

c=3E8

2752

c=3E8

2748

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

2753

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

2749

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

2754

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

2750

2755

2751

colList = []

2756

colList = []

2752

2757

2753

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

2758

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

2754

2759

2755

colList.append(colFreq)

2760

colList.append(colFreq)

2756

2761

2757

nchannel=self.dataOut.nChannels

2762

nchannel=self.dataOut.nChannels

2758

2763

2759

for i in range(nchannel):

2764

for i in range(nchannel):

2760

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

2765

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

2761

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

2766

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

2762

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

2767

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

2763

2768

2764

colList.append(col)

2769

colList.append(col)

2765

2770

2766

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

2771

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

2767

2772

2768

self.wrObj.CFile(header,data)

2773

self.wrObj.CFile(header,data)

2769

2774

2770

self.wrObj.wFile(filename)

2775

self.wrObj.wFile(filename)

2771

2776

2772

#update the setFile

2777

#update the setFile

2773

self.setFile += 1

2778

self.setFile += 1

2774

self.idblock += 1

2779

self.idblock += 1

2775

2780

2776

return 1

2781

return 1

2777

2782

2778

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

2783

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

2779

2784

2780

if not(self.isConfig):

2785

if not(self.isConfig):

2781

2786

2782

self.setup(dataOut, **kwargs)

2787

self.setup(dataOut, **kwargs)

2783

self.isConfig = True

2788

self.isConfig = True

2784

2789

2785

self.putData()

2790

self.putData()

2786

2791

2787

2792

2788

2793

2789

class ParameterConf:

2794

class ParameterConf:

2790

ELEMENTNAME = 'Parameter'

2795

ELEMENTNAME = 'Parameter'

2791

def __init__(self):

2796

def __init__(self):

2792

self.name = ''

2797

self.name = ''

2793

self.value = ''

2798

self.value = ''

2794

2799

2795

def readXml(self, parmElement):

2800

def readXml(self, parmElement):

2796

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

2801

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

2797

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

2802

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

2798

2803

2799

def getElementName(self):

2804

def getElementName(self):

2800

return self.ELEMENTNAME

2805

return self.ELEMENTNAME

2801

2806

2802

class Metadata:

2807

class Metadata:

2803

2808

2804

def __init__(self, filename):

2809

def __init__(self, filename):

2805

self.parmConfObjList = []

2810

self.parmConfObjList = []

2806

self.readXml(filename)

2811

self.readXml(filename)

2807

2812

2808

def readXml(self, filename):

2813

def readXml(self, filename):

2809

self.projectElement = None

2814

self.projectElement = None

2810

self.procUnitConfObjDict = {}

2815

self.procUnitConfObjDict = {}

2811

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

2816

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

2812

self.project = self.projectElement.tag

2817

self.project = self.projectElement.tag

2813

2818

2814

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

2819

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

2815

2820

2816

for parmElement in parmElementList:

2821

for parmElement in parmElementList:

2817

parmConfObj = ParameterConf()

2822

parmConfObj = ParameterConf()

2818

parmConfObj.readXml(parmElement)

2823

parmConfObj.readXml(parmElement)

2819

self.parmConfObjList.append(parmConfObj)

2824

self.parmConfObjList.append(parmConfObj)

2820

2825

2821

class FitsWriter(Operation):

2826

class FitsWriter(Operation):

2822

2827

2823

def __init__(self):

2828

def __init__(self):

2824

self.isConfig = False

2829

self.isConfig = False

2825

self.dataBlocksPerFile = None

2830

self.dataBlocksPerFile = None

2826

self.blockIndex = 0

2831

self.blockIndex = 0

2827

self.flagIsNewFile = 1

2832

self.flagIsNewFile = 1

2828

self.fitsObj = None

2833

self.fitsObj = None

2829

self.optchar = 'P'

2834

self.optchar = 'P'

2830

self.ext = '.fits'

2835

self.ext = '.fits'

2831

self.setFile = 0

2836

self.setFile = 0

2832

2837

2833

def setFitsHeader(self, dataOut, metadatafile):

2838

def setFitsHeader(self, dataOut, metadatafile):

2834

2839

2835

header_data = pyfits.PrimaryHDU()

2840

header_data = pyfits.PrimaryHDU()

2836

2841

2837

metadata4fits = Metadata(metadatafile)

2842

metadata4fits = Metadata(metadatafile)

2838

for parameter in metadata4fits.parmConfObjList:

2843

for parameter in metadata4fits.parmConfObjList:

2839

parm_name = parameter.name

2844

parm_name = parameter.name

2840

parm_value = parameter.value

2845

parm_value = parameter.value

2841

2846

2842

# if parm_value == 'fromdatadatetime':

2847

# if parm_value == 'fromdatadatetime':

2843

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

2848

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

2844

# elif parm_value == 'fromdataheights':

2849

# elif parm_value == 'fromdataheights':

2845

# value = dataOut.nHeights

2850

# value = dataOut.nHeights

2846

# elif parm_value == 'fromdatachannel':

2851

# elif parm_value == 'fromdatachannel':

2847

# value = dataOut.nChannels

2852

# value = dataOut.nChannels

2848

# elif parm_value == 'fromdatasamples':

2853

# elif parm_value == 'fromdatasamples':

2849

# value = dataOut.nFFTPoints

2854

# value = dataOut.nFFTPoints

2850

# else:

2855

# else:

2851

# value = parm_value

2856

# value = parm_value

2852

2857

2853

header_data.header[parm_name] = parm_value

2858

header_data.header[parm_name] = parm_value

2854

2859

2855

2860

2856

header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())

2861

header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())

2857

header_data.header['CHANNELLIST'] = str(dataOut.channelList)

2862

header_data.header['CHANNELLIST'] = str(dataOut.channelList)

2858

header_data.header['NCHANNELS'] = dataOut.nChannels

2863

header_data.header['NCHANNELS'] = dataOut.nChannels

2859

#header_data.header['HEIGHTS'] = dataOut.heightList

2864

#header_data.header['HEIGHTS'] = dataOut.heightList

2860

header_data.header['NHEIGHTS'] = dataOut.nHeights

2865

header_data.header['NHEIGHTS'] = dataOut.nHeights

2861

2866

2862

header_data.header['IPPSECONDS'] = dataOut.ippSeconds

2867

header_data.header['IPPSECONDS'] = dataOut.ippSeconds

2863

header_data.header['NCOHINT'] = dataOut.nCohInt

2868

header_data.header['NCOHINT'] = dataOut.nCohInt

2864

header_data.header['NINCOHINT'] = dataOut.nIncohInt

2869

header_data.header['NINCOHINT'] = dataOut.nIncohInt

2865

header_data.header['TIMEZONE'] = dataOut.timeZone

2870

header_data.header['TIMEZONE'] = dataOut.timeZone

2866

header_data.header['NBLOCK'] = self.blockIndex

2871

header_data.header['NBLOCK'] = self.blockIndex

2867

2872

2868

header_data.writeto(self.filename)

2873

header_data.writeto(self.filename)

2869

2874

2870

self.addExtension(dataOut.heightList,'HEIGHTLIST')

2875

self.addExtension(dataOut.heightList,'HEIGHTLIST')

2871

2876

2872

2877

2873

def setup(self, dataOut, path, dataBlocksPerFile, metadatafile):

2878

def setup(self, dataOut, path, dataBlocksPerFile, metadatafile):

2874

2879

2875

self.path = path

2880

self.path = path

2876

self.dataOut = dataOut

2881

self.dataOut = dataOut

2877

self.metadatafile = metadatafile

2882

self.metadatafile = metadatafile

2878

self.dataBlocksPerFile = dataBlocksPerFile

2883

self.dataBlocksPerFile = dataBlocksPerFile

2879

2884

2880

def open(self):

2885

def open(self):

2881

self.fitsObj = pyfits.open(self.filename, mode='update')

2886

self.fitsObj = pyfits.open(self.filename, mode='update')

2882

2887

2883

2888

2884

def addExtension(self, data, tagname):

2889

def addExtension(self, data, tagname):

2885

self.open()

2890

self.open()

2886

extension = pyfits.ImageHDU(data=data, name=tagname)

2891

extension = pyfits.ImageHDU(data=data, name=tagname)

2887

#extension.header['TAG'] = tagname

2892

#extension.header['TAG'] = tagname

2888

self.fitsObj.append(extension)

2893

self.fitsObj.append(extension)

2889

self.write()

2894

self.write()

2890

2895

2891

def addData(self, data):

2896

def addData(self, data):

2892

self.open()

2897

self.open()

2893

extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])

2898

extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])

2894

extension.header['UTCTIME'] = self.dataOut.utctime

2899

extension.header['UTCTIME'] = self.dataOut.utctime

2895

self.fitsObj.append(extension)

2900

self.fitsObj.append(extension)

2896

self.blockIndex += 1

2901

self.blockIndex += 1

2897

self.fitsObj[0].header['NBLOCK'] = self.blockIndex

2902

self.fitsObj[0].header['NBLOCK'] = self.blockIndex

2898

2903

2899

self.write()

2904

self.write()

2900

2905

2901

def write(self):

2906

def write(self):

2902

2907

2903

self.fitsObj.flush(verbose=True)

2908

self.fitsObj.flush(verbose=True)

2904

self.fitsObj.close()

2909

self.fitsObj.close()

2905

2910

2906

2911

2907

def setNextFile(self):

2912

def setNextFile(self):

2908

2913

2909

ext = self.ext

2914

ext = self.ext

2910

path = self.path

2915

path = self.path

2911

2916

2912

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

2917

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

2913

subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)

2918

subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)

2914

2919

2915

fullpath = os.path.join( path, subfolder )

2920

fullpath = os.path.join( path, subfolder )

2916

if not( os.path.exists(fullpath) ):

2921

if not( os.path.exists(fullpath) ):

2917

os.mkdir(fullpath)

2922

os.mkdir(fullpath)

2918

self.setFile = -1 #inicializo mi contador de seteo

2923

self.setFile = -1 #inicializo mi contador de seteo

2919

else:

2924

else:

2920

filesList = os.listdir( fullpath )

2925

filesList = os.listdir( fullpath )

2921

if len( filesList ) > 0:

2926

if len( filesList ) > 0:

2922

filesList = sorted( filesList, key=str.lower )

2927

filesList = sorted( filesList, key=str.lower )

2923

filen = filesList[-1]

2928

filen = filesList[-1]

2924

2929

2925

if isNumber( filen[8:11] ):

2930

if isNumber( filen[8:11] ):

2926

self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file

2931

self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file

2927

else:

2932

else:

2928

self.setFile = -1

2933

self.setFile = -1

2929

else:

2934

else:

2930

self.setFile = -1 #inicializo mi contador de seteo

2935

self.setFile = -1 #inicializo mi contador de seteo

2931

2936

2932

setFile = self.setFile

2937

setFile = self.setFile

2933

setFile += 1

2938

setFile += 1

2934

2939

2935

file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,

2940

file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,

2936

timeTuple.tm_year,

2941

timeTuple.tm_year,

2937

timeTuple.tm_yday,

2942

timeTuple.tm_yday,

2938

setFile,

2943

setFile,

2939

ext )

2944

ext )

2940

2945

2941

filename = os.path.join( path, subfolder, file )

2946

filename = os.path.join( path, subfolder, file )

2942

2947

2943

self.blockIndex = 0

2948

self.blockIndex = 0

2944

self.filename = filename

2949

self.filename = filename

2945

self.setFile = setFile

2950

self.setFile = setFile

2946

self.flagIsNewFile = 1

2951

self.flagIsNewFile = 1

2947

2952

2948

print 'Writing the file: %s'%self.filename

2953

print 'Writing the file: %s'%self.filename

2949

2954

2950

self.setFitsHeader(self.dataOut, self.metadatafile)

2955

self.setFitsHeader(self.dataOut, self.metadatafile)

2951

2956

2952

return 1

2957

return 1

2953

2958

2954

def writeBlock(self):

2959

def writeBlock(self):

2955

self.addData(self.dataOut.data_spc)

2960

self.addData(self.dataOut.data_spc)

2956

self.flagIsNewFile = 0

2961

self.flagIsNewFile = 0

2957

2962

2958

2963

2959

def __setNewBlock(self):

2964

def __setNewBlock(self):

2960

2965

2961

if self.flagIsNewFile:

2966

if self.flagIsNewFile:

2962

return 1

2967

return 1

2963

2968

2964

if self.blockIndex < self.dataBlocksPerFile:

2969

if self.blockIndex < self.dataBlocksPerFile:

2965

return 1

2970

return 1

2966

2971

2967

if not( self.setNextFile() ):

2972

if not( self.setNextFile() ):

2968

return 0

2973

return 0

2969

2974

2970

return 1

2975

return 1

2971

2976

2972

def writeNextBlock(self):

2977

def writeNextBlock(self):

2973

if not( self.__setNewBlock() ):

2978

if not( self.__setNewBlock() ):

2974

return 0

2979

return 0

2975

self.writeBlock()

2980

self.writeBlock()

2976

return 1

2981

return 1

2977

2982

2978

def putData(self):

2983

def putData(self):

2979

if self.flagIsNewFile:

2984

if self.flagIsNewFile:

2980

self.setNextFile()

2985

self.setNextFile()

2981

self.writeNextBlock()

2986

self.writeNextBlock()

2982

2987

2983

def run(self, dataOut, **kwargs):

2988

def run(self, dataOut, **kwargs):

2984

if not(self.isConfig):

2989

if not(self.isConfig):

2985

self.setup(dataOut, **kwargs)

2990

self.setup(dataOut, **kwargs)

2986

self.isConfig = True

2991

self.isConfig = True

2987

self.putData()

2992

self.putData()

2988

2993

2989

2994

2990

class FitsReader(ProcessingUnit):

2995

class FitsReader(ProcessingUnit):

2991

2996

2992

# __TIMEZONE = time.timezone

2997

# __TIMEZONE = time.timezone

2993

2998

2994

expName = None

2999

expName = None

2995

datetimestr = None

3000

datetimestr = None

2996

utc = None

3001

utc = None

2997

nChannels = None

3002

nChannels = None

2998

nSamples = None

3003

nSamples = None

2999

dataBlocksPerFile = None

3004

dataBlocksPerFile = None

3000

comments = None

3005

comments = None

3001

lastUTTime = None

3006

lastUTTime = None

3002

header_dict = None

3007

header_dict = None

3003

data = None

3008

data = None

3004

data_header_dict = None

3009

data_header_dict = None

3005

3010

3006

def __init__(self):

3011

def __init__(self):

3007

self.isConfig = False

3012

self.isConfig = False

3008

self.ext = '.fits'

3013

self.ext = '.fits'

3009

self.setFile = 0

3014

self.setFile = 0

3010

self.flagNoMoreFiles = 0

3015

self.flagNoMoreFiles = 0

3011

self.flagIsNewFile = 1

3016

self.flagIsNewFile = 1

3012

self.flagTimeBlock = None

3017

self.flagTimeBlock = None

3013

self.fileIndex = None

3018

self.fileIndex = None

3014

self.filename = None

3019

self.filename = None

3015

self.fileSize = None

3020

self.fileSize = None

3016

self.fitsObj = None

3021

self.fitsObj = None

3017

self.timeZone = None

3022

self.timeZone = None

3018

self.nReadBlocks = 0

3023

self.nReadBlocks = 0

3019

self.nTotalBlocks = 0

3024

self.nTotalBlocks = 0

3020

self.dataOut = self.createObjByDefault()

3025

self.dataOut = self.createObjByDefault()

3021

self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()

3026

self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()

3022

self.blockIndex = 1

3027

self.blockIndex = 1

3023

3028

3024

def createObjByDefault(self):

3029

def createObjByDefault(self):

3025

3030

3026

dataObj = Fits()

3031

dataObj = Fits()

3027

3032

3028

return dataObj

3033

return dataObj

3029

3034

3030

def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):

3035

def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):

3031

try:

3036

try:

3032

fitsObj = pyfits.open(filename,'readonly')

3037

fitsObj = pyfits.open(filename,'readonly')

3033

except:

3038

except:

3034

raise IOError, "The file %s can't be opened" %(filename)

3039

raise IOError, "The file %s can't be opened" %(filename)

3035

3040

3036

header = fitsObj[0].header

3041

header = fitsObj[0].header

3037

struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")

3042

struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")

3038

utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS

3043

utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS

3039

3044

3040

ltc = utc

3045

ltc = utc

3041

if useLocalTime:

3046

if useLocalTime:

3042

ltc -= time.timezone

3047

ltc -= time.timezone

3043

thisDatetime = datetime.datetime.utcfromtimestamp(ltc)

3048

thisDatetime = datetime.datetime.utcfromtimestamp(ltc)

3044

thisTime = thisDatetime.time()

3049

thisTime = thisDatetime.time()

3045

3050

3046

if not ((startTime <= thisTime) and (endTime > thisTime)):

3051

if not ((startTime <= thisTime) and (endTime > thisTime)):

3047

return None

3052

return None

3048

3053

3049

return thisDatetime

3054

return thisDatetime

3050

3055

3051

def __setNextFileOnline(self):

3056

def __setNextFileOnline(self):

3052

raise ValueError, "No implemented"

3057

raise ValueError, "No implemented"

3053

3058

3054

def __setNextFileOffline(self):

3059

def __setNextFileOffline(self):

3055

idFile = self.fileIndex

3060

idFile = self.fileIndex

3056

3061

3057

while (True):

3062

while (True):

3058

idFile += 1

3063

idFile += 1

3059

if not(idFile < len(self.filenameList)):

3064

if not(idFile < len(self.filenameList)):

3060

self.flagNoMoreFiles = 1

3065

self.flagNoMoreFiles = 1

3061

print "No more Files"

3066

print "No more Files"

3062

return 0

3067

return 0

3063

3068

3064

filename = self.filenameList[idFile]

3069

filename = self.filenameList[idFile]

3065

3070

3066

# if not(self.__verifyFile(filename)):

3071

# if not(self.__verifyFile(filename)):

3067

# continue

3072

# continue

3068

3073

3069

fileSize = os.path.getsize(filename)

3074

fileSize = os.path.getsize(filename)

3070

fitsObj = pyfits.open(filename,'readonly')

3075

fitsObj = pyfits.open(filename,'readonly')

3071

break

3076

break

3072

3077

3073

self.flagIsNewFile = 1

3078

self.flagIsNewFile = 1

3074

self.fileIndex = idFile

3079

self.fileIndex = idFile

3075

self.filename = filename

3080

self.filename = filename

3076

self.fileSize = fileSize

3081

self.fileSize = fileSize

3077

self.fitsObj = fitsObj

3082

self.fitsObj = fitsObj

3078

self.blockIndex = 0

3083

self.blockIndex = 0

3079

print "Setting the file: %s"%self.filename

3084

print "Setting the file: %s"%self.filename

3080

3085

3081

return 1

3086

return 1

3082

3087

3083

def readHeader(self):

3088

def readHeader(self):

3084

headerObj = self.fitsObj[0]

3089

headerObj = self.fitsObj[0]

3085

3090

3086

self.header_dict = headerObj.header

3091

self.header_dict = headerObj.header

3087

if 'EXPNAME' in headerObj.header.keys():

3092

if 'EXPNAME' in headerObj.header.keys():

3088

self.expName = headerObj.header['EXPNAME']

3093

self.expName = headerObj.header['EXPNAME']

3089

3094

3090

if 'DATATYPE' in headerObj.header.keys():

3095

if 'DATATYPE' in headerObj.header.keys():

3091

self.dataType = headerObj.header['DATATYPE']

3096

self.dataType = headerObj.header['DATATYPE']

3092

3097

3093

self.datetimestr = headerObj.header['DATETIME']

3098

self.datetimestr = headerObj.header['DATETIME']

3094

channelList = headerObj.header['CHANNELLIST']

3099

channelList = headerObj.header['CHANNELLIST']

3095

channelList = channelList.split('[')

3100

channelList = channelList.split('[')

3096

channelList = channelList[1].split(']')

3101

channelList = channelList[1].split(']')

3097

channelList = channelList[0].split(',')

3102

channelList = channelList[0].split(',')

3098

channelList = [int(ch) for ch in channelList]

3103

channelList = [int(ch) for ch in channelList]

3099

self.channelList = channelList

3104

self.channelList = channelList

3100

self.nChannels = headerObj.header['NCHANNELS']

3105

self.nChannels = headerObj.header['NCHANNELS']

3101

self.nHeights = headerObj.header['NHEIGHTS']

3106

self.nHeights = headerObj.header['NHEIGHTS']

3102

self.ippSeconds = headerObj.header['IPPSECONDS']

3107

self.ippSeconds = headerObj.header['IPPSECONDS']

3103

self.nCohInt = headerObj.header['NCOHINT']

3108

self.nCohInt = headerObj.header['NCOHINT']

3104

self.nIncohInt = headerObj.header['NINCOHINT']

3109

self.nIncohInt = headerObj.header['NINCOHINT']

3105

self.dataBlocksPerFile = headerObj.header['NBLOCK']

3110

self.dataBlocksPerFile = headerObj.header['NBLOCK']

3106

self.timeZone = headerObj.header['TIMEZONE']

3111

self.timeZone = headerObj.header['TIMEZONE']

3107

3112

3108

self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt

3113

self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt

3109

3114

3110

if 'COMMENT' in headerObj.header.keys():

3115

if 'COMMENT' in headerObj.header.keys():

3111

self.comments = headerObj.header['COMMENT']

3116

self.comments = headerObj.header['COMMENT']

3112

3117

3113

self.readHeightList()

3118

self.readHeightList()

3114

3119

3115

def readHeightList(self):

3120

def readHeightList(self):

3116

self.blockIndex = self.blockIndex + 1

3121

self.blockIndex = self.blockIndex + 1

3117

obj = self.fitsObj[self.blockIndex]

3122

obj = self.fitsObj[self.blockIndex]

3118

self.heightList = obj.data

3123

self.heightList = obj.data

3119

self.blockIndex = self.blockIndex + 1

3124

self.blockIndex = self.blockIndex + 1

3120

3125

3121

def readExtension(self):

3126

def readExtension(self):

3122

obj = self.fitsObj[self.blockIndex]

3127

obj = self.fitsObj[self.blockIndex]

3123

self.heightList = obj.data

3128

self.heightList = obj.data

3124

self.blockIndex = self.blockIndex + 1

3129

self.blockIndex = self.blockIndex + 1

3125

3130

3126

def setNextFile(self):

3131

def setNextFile(self):

3127

3132

3128

if self.online:

3133

if self.online:

3129

newFile = self.__setNextFileOnline()

3134

newFile = self.__setNextFileOnline()

3130

else:

3135

else:

3131

newFile = self.__setNextFileOffline()

3136

newFile = self.__setNextFileOffline()

3132

3137

3133

if not(newFile):

3138

if not(newFile):

3134

return 0

3139

return 0

3135

3140

3136

self.readHeader()

3141

self.readHeader()

3137

3142

3138

self.nReadBlocks = 0

3143

self.nReadBlocks = 0

3139

# self.blockIndex = 1

3144

# self.blockIndex = 1

3140

return 1

3145

return 1

3141

3146

3142

def __searchFilesOffLine(self,

3147

def __searchFilesOffLine(self,

3143

path,

3148

path,

3144

startDate,

3149

startDate,

3145

endDate,

3150

endDate,

3146

startTime=datetime.time(0,0,0),

3151

startTime=datetime.time(0,0,0),

3147

endTime=datetime.time(23,59,59),

3152

endTime=datetime.time(23,59,59),

3148

set=None,

3153

set=None,

3149

expLabel='',

3154

expLabel='',

3150

ext='.fits',

3155

ext='.fits',

3151

walk=True):

3156

walk=True):

3152

3157

3153

pathList = []

3158

pathList = []

3154

3159

3155

if not walk:

3160

if not walk:

3156

pathList.append(path)

3161

pathList.append(path)

3157

3162

3158

else:

3163

else:

3159

dirList = []

3164

dirList = []

3160

for thisPath in os.listdir(path):

3165

for thisPath in os.listdir(path):

3161

if not os.path.isdir(os.path.join(path,thisPath)):

3166

if not os.path.isdir(os.path.join(path,thisPath)):

3162

continue

3167

continue

3163

if not isDoyFolder(thisPath):

3168

if not isDoyFolder(thisPath):

3164

continue

3169

continue

3165

3170

3166

dirList.append(thisPath)

3171

dirList.append(thisPath)

3167

3172

3168

if not(dirList):

3173

if not(dirList):

3169

return None, None

3174

return None, None

3170

3175

3171

thisDate = startDate

3176

thisDate = startDate

3172

3177

3173

while(thisDate <= endDate):

3178

while(thisDate <= endDate):

3174

year = thisDate.timetuple().tm_year

3179

year = thisDate.timetuple().tm_year

3175

doy = thisDate.timetuple().tm_yday

3180

doy = thisDate.timetuple().tm_yday

3176

3181

3177

matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')

3182

matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')

3178

if len(matchlist) == 0:

3183

if len(matchlist) == 0:

3179

thisDate += datetime.timedelta(1)

3184

thisDate += datetime.timedelta(1)

3180

continue

3185

continue

3181

for match in matchlist:

3186

for match in matchlist:

3182

pathList.append(os.path.join(path,match,expLabel))

3187

pathList.append(os.path.join(path,match,expLabel))

3183

3188

3184

thisDate += datetime.timedelta(1)

3189

thisDate += datetime.timedelta(1)

3185

3190

3186

if pathList == []:

3191

if pathList == []:

3187

print "Any folder was found for the date range: %s-%s" %(startDate, endDate)

3192

print "Any folder was found for the date range: %s-%s" %(startDate, endDate)

3188

return None, None

3193

return None, None

3189

3194

3190

print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)

3195

print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)

3191

3196

3192

filenameList = []

3197

filenameList = []

3193

datetimeList = []

3198

datetimeList = []

3194

3199

3195

for i in range(len(pathList)):

3200

for i in range(len(pathList)):

3196

3201

3197

thisPath = pathList[i]

3202

thisPath = pathList[i]

3198

3203

3199

fileList = glob.glob1(thisPath, "*%s" %ext)

3204

fileList = glob.glob1(thisPath, "*%s" %ext)

3200

fileList.sort()

3205

fileList.sort()

3201

3206

3202

for file in fileList:

3207

for file in fileList:

3203

3208

3204

filename = os.path.join(thisPath,file)

3209

filename = os.path.join(thisPath,file)

3205

thisDatetime = self.isFileinThisTime(filename, startTime, endTime)

3210

thisDatetime = self.isFileinThisTime(filename, startTime, endTime)

3206

3211

3207

if not(thisDatetime):

3212

if not(thisDatetime):

3208

continue

3213

continue

3209

3214

3210

filenameList.append(filename)

3215

filenameList.append(filename)

3211

datetimeList.append(thisDatetime)

3216

datetimeList.append(thisDatetime)

3212

3217

3213

if not(filenameList):

3218

if not(filenameList):

3214

print "Any file was found for the time range %s - %s" %(startTime, endTime)

3219

print "Any file was found for the time range %s - %s" %(startTime, endTime)

3215

return None, None

3220

return None, None

3216

3221

3217

print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)

3222

print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)

3218

print

3223

print

3219

3224

3220

for i in range(len(filenameList)):

3225

for i in range(len(filenameList)):

3221

print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())

3226

print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())

3222

3227

3223

self.filenameList = filenameList

3228

self.filenameList = filenameList

3224

self.datetimeList = datetimeList

3229

self.datetimeList = datetimeList

3225

3230

3226

return pathList, filenameList

3231

return pathList, filenameList

3227

3232

3228

def setup(self, path=None,

3233

def setup(self, path=None,

3229

startDate=None,

3234

startDate=None,

3230

endDate=None,

3235

endDate=None,

3231

startTime=datetime.time(0,0,0),

3236

startTime=datetime.time(0,0,0),

3232

endTime=datetime.time(23,59,59),

3237

endTime=datetime.time(23,59,59),

3233

set=0,

3238

set=0,

3234

expLabel = "",

3239

expLabel = "",

3235

ext = None,

3240

ext = None,

3236

online = False,

3241

online = False,

3237

delay = 60,

3242

delay = 60,

3238

walk = True):

3243

walk = True):

3239

3244

3240

if path == None:

3245

if path == None:

3241

raise ValueError, "The path is not valid"

3246

raise ValueError, "The path is not valid"

3242

3247

3243

if ext == None:

3248

if ext == None:

3244

ext = self.ext

3249

ext = self.ext

3245

3250

3246

if not(online):

3251

if not(online):

3247

print "Searching files in offline mode ..."

3252

print "Searching files in offline mode ..."

3248

pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,

3253

pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,

3249

startTime=startTime, endTime=endTime,

3254

startTime=startTime, endTime=endTime,

3250

set=set, expLabel=expLabel, ext=ext,

3255

set=set, expLabel=expLabel, ext=ext,

3251

walk=walk)

3256

walk=walk)

3252

3257

3253

if not(pathList):

3258

if not(pathList):

3254

print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,

3259

print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,

3255

datetime.datetime.combine(startDate,startTime).ctime(),

3260

datetime.datetime.combine(startDate,startTime).ctime(),

3256

datetime.datetime.combine(endDate,endTime).ctime())

3261

datetime.datetime.combine(endDate,endTime).ctime())

3257

3262

3258

sys.exit(-1)

3263

sys.exit(-1)

3259

3264

3260

self.fileIndex = -1

3265

self.fileIndex = -1

3261

self.pathList = pathList

3266

self.pathList = pathList

3262

self.filenameList = filenameList

3267

self.filenameList = filenameList

3263

3268

3264

self.online = online

3269

self.online = online

3265

self.delay = delay

3270

self.delay = delay

3266

ext = ext.lower()

3271

ext = ext.lower()

3267

self.ext = ext

3272

self.ext = ext

3268

3273

3269

if not(self.setNextFile()):

3274

if not(self.setNextFile()):

3270

if (startDate!=None) and (endDate!=None):

3275

if (startDate!=None) and (endDate!=None):

3271

print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())

3276

print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())

3272

elif startDate != None:

3277

elif startDate != None:

3273

print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())

3278

print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())

3274

else:

3279

else:

3275

print "No files"

3280

print "No files"

3276

3281

3277

sys.exit(-1)

3282

sys.exit(-1)

3278

3283

3279

3284

3280

3285

3281

def readBlock(self):

3286

def readBlock(self):

3282

dataObj = self.fitsObj[self.blockIndex]

3287

dataObj = self.fitsObj[self.blockIndex]

3283

3288

3284

self.data = dataObj.data

3289

self.data = dataObj.data

3285

self.data_header_dict = dataObj.header

3290

self.data_header_dict = dataObj.header

3286

self.utc = self.data_header_dict['UTCTIME']

3291

self.utc = self.data_header_dict['UTCTIME']

3287

3292

3288

self.flagIsNewFile = 0

3293

self.flagIsNewFile = 0

3289

self.blockIndex += 1

3294

self.blockIndex += 1

3290

self.nTotalBlocks += 1

3295

self.nTotalBlocks += 1

3291

self.nReadBlocks += 1

3296

self.nReadBlocks += 1

3292

3297

3293

return 1

3298

return 1

3294

3299

3295

def __jumpToLastBlock(self):

3300

def __jumpToLastBlock(self):

3296

raise ValueError, "No implemented"

3301

raise ValueError, "No implemented"

3297

3302

3298

def __waitNewBlock(self):

3303

def __waitNewBlock(self):

3299

"""

3304

"""

3300

Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.

3305

Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.

3301

3306

3302

Si el modo de lectura es OffLine siempre retorn 0

3307

Si el modo de lectura es OffLine siempre retorn 0

3303

"""

3308

"""

3304

if not self.online:

3309

if not self.online:

3305

return 0

3310

return 0

3306

3311

3307

if (self.nReadBlocks >= self.dataBlocksPerFile):

3312

if (self.nReadBlocks >= self.dataBlocksPerFile):

3308

return 0

3313

return 0

3309

3314

3310

currentPointer = self.fp.tell()

3315

currentPointer = self.fp.tell()

3311

3316

3312

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

3317

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

3313

3318

3314

for nTries in range( self.nTries ):

3319

for nTries in range( self.nTries ):

3315

3320

3316

self.fp.close()

3321

self.fp.close()

3317

self.fp = open( self.filename, 'rb' )

3322

self.fp = open( self.filename, 'rb' )

3318

self.fp.seek( currentPointer )

3323

self.fp.seek( currentPointer )

3319

3324

3320

self.fileSize = os.path.getsize( self.filename )

3325

self.fileSize = os.path.getsize( self.filename )

3321

currentSize = self.fileSize - currentPointer

3326

currentSize = self.fileSize - currentPointer

3322

3327

3323

if ( currentSize >= neededSize ):

3328

if ( currentSize >= neededSize ):

3324

self.__rdBasicHeader()

3329

self.__rdBasicHeader()

3325

return 1

3330

return 1

3326

3331

3327

print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)

3332

print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)

3328

time.sleep( self.delay )

3333

time.sleep( self.delay )

3329

3334

3330

3335

3331

return 0

3336

return 0

3332

3337

3333

def __setNewBlock(self):

3338

def __setNewBlock(self):

3334

3339

3335

if self.online:

3340

if self.online:

3336

self.__jumpToLastBlock()

3341

self.__jumpToLastBlock()

3337

3342

3338

if self.flagIsNewFile:

3343

if self.flagIsNewFile:

3339

return 1

3344

return 1

3340

3345

3341

self.lastUTTime = self.utc

3346

self.lastUTTime = self.utc

3342

3347

3343

if self.online:

3348

if self.online:

3344

if self.__waitNewBlock():

3349

if self.__waitNewBlock():

3345

return 1

3350

return 1

3346

3351

3347

if self.nReadBlocks < self.dataBlocksPerFile:

3352

if self.nReadBlocks < self.dataBlocksPerFile:

3348

return 1

3353

return 1

3349

3354

3350

if not(self.setNextFile()):

3355

if not(self.setNextFile()):

3351

return 0

3356

return 0

3352

3357

3353

deltaTime = self.utc - self.lastUTTime

3358

deltaTime = self.utc - self.lastUTTime

3354

3359

3355

self.flagTimeBlock = 0

3360

self.flagTimeBlock = 0

3356

3361

3357

if deltaTime > self.maxTimeStep:

3362

if deltaTime > self.maxTimeStep:

3358

self.flagTimeBlock = 1

3363

self.flagTimeBlock = 1

3359

3364

3360

return 1

3365

return 1

3361

3366

3362

3367

3363

def readNextBlock(self):

3368

def readNextBlock(self):

3364

if not(self.__setNewBlock()):

3369

if not(self.__setNewBlock()):

3365

return 0

3370

return 0

3366

3371

3367

if not(self.readBlock()):

3372

if not(self.readBlock()):

3368

return 0

3373

return 0

3369

3374

3370

return 1

3375

return 1

3371

3376

3372

3377

3373

def getData(self):

3378

def getData(self):

3374

3379

3375

if self.flagNoMoreFiles:

3380

if self.flagNoMoreFiles:

3376

self.dataOut.flagNoData = True

3381

self.dataOut.flagNoData = True

3377

print 'Process finished'

3382

print 'Process finished'

3378

return 0

3383

return 0

3379

3384

3380

self.flagTimeBlock = 0

3385

self.flagTimeBlock = 0

3381

self.flagIsNewBlock = 0

3386

self.flagIsNewBlock = 0

3382

3387

3383

if not(self.readNextBlock()):

3388

if not(self.readNextBlock()):

3384

return 0

3389

return 0

3385

3390

3386

if self.data == None:

3391

if self.data == None:

3387

self.dataOut.flagNoData = True

3392

self.dataOut.flagNoData = True

3388

return 0

3393

return 0

3389

3394

3390

self.dataOut.data = self.data

3395

self.dataOut.data = self.data

3391

self.dataOut.data_header = self.data_header_dict

3396

self.dataOut.data_header = self.data_header_dict

3392

self.dataOut.utctime = self.utc

3397

self.dataOut.utctime = self.utc

3393

3398

3394

self.dataOut.header = self.header_dict

3399

self.dataOut.header = self.header_dict

3395

self.dataOut.expName = self.expName

3400

self.dataOut.expName = self.expName

3396

self.dataOut.nChannels = self.nChannels

3401

self.dataOut.nChannels = self.nChannels

3397

self.dataOut.timeZone = self.timeZone

3402

self.dataOut.timeZone = self.timeZone

3398

self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile

3403

self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile

3399

self.dataOut.comments = self.comments

3404

self.dataOut.comments = self.comments

3400

self.dataOut.timeInterval = self.timeInterval

3405

self.dataOut.timeInterval = self.timeInterval

3401

self.dataOut.channelList = self.channelList

3406

self.dataOut.channelList = self.channelList

3402

self.dataOut.heightList = self.heightList

3407

self.dataOut.heightList = self.heightList

3403

self.dataOut.flagNoData = False

3408

self.dataOut.flagNoData = False

3404

3409

3405

return self.dataOut.data

3410

return self.dataOut.data

3406

3411

3407

def run(self, **kwargs):

3412

def run(self, **kwargs):

3408

3413

3409

if not(self.isConfig):

3414

if not(self.isConfig):

3410

self.setup(**kwargs)

3415

self.setup(**kwargs)

3411

self.isConfig = True

3416

self.isConfig = True

3412

3417

3413

self.getData() No newline at end of file

3418

self.getData()

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages