diff --git a/schainpy/IO/DataIO.py b/schainpy/IO/DataIO.py index 60a1571..7b18f46 100644 --- a/schainpy/IO/DataIO.py +++ b/schainpy/IO/DataIO.py @@ -17,40 +17,6 @@ sys.path.append(path) from Model.JROHeader import * from Model.JROData import JROData - -def isFileOK(filename): - """ - Determina si la cabecera de un archivo es valido o no, si lo es entonces seria un archivo que podria contener data, - si no seria un archivo invalido - - Return: - True : si es un archivo valido - False : si no es un archivo valido - - Exceptions: - Si al leer la cabecera esta no coincide con el tipo de las variables que la contienen entonces se dispara - una exception - """ - m_BasicHeader = BasicHeader() - m_ProcessingHeader = ProcessingHeader() - m_RadarControllerHeader = RadarControllerHeader() - m_SystemHeader = SystemHeader() - fp = None - - try: - fp = open( filename,'rb' ) - m_BasicHeader.read(fp) - m_SystemHeader.read(fp) - m_RadarControllerHeader.read(fp) - m_ProcessingHeader.read(fp) - fp.close() - except: - if fp != None: fp.close() - return False - - return True - - def checkForRealPath(path, year, doy, set, ext): """ Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path, @@ -150,52 +116,54 @@ def isThisFileinRange(filename, startUTSeconds, endUTSeconds): except: raise IOError, "The file %s can't be opened" %(filename) - if not(m_BasicHeader.read(fp)): - raise IOError, "The file %s has not a valid header" %(filename) - + sts = m_BasicHeader.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 <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)): return 0 return 1 -def getlastFileFromPath(pathList, ext): +def getlastFileFromPath(path, ext): """ - Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.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: - pathList : lista conteniendo todos los filename completos que componen una determinada carpeta + 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 + El ultimo file de una determinada carpeta, no se considera el path. """ - filesList = [] - filename = None - + validFilelist = [] + fileList = os.listdir(path) + # 0 1234 567 89A BCDE # D YYYY DDD SSS .ext - for filename in pathList: - year = filename[1:5] - doy = filename[5:8] - leng = len( ext ) + for file in fileList: + try: + year = int(file[1:5]) + doy = int(file[5:8]) + except: + continue - if ( filename[-leng:].upper() != ext.upper() ) : continue - if not( isNumber( year ) ) : continue - if not( isNumber( doy ) ) : continue + if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue - filesList.append(filename) + validFilelist.append(file) - if len( filesList ) > 0: - filesList = sorted( filesList, key=str.lower ) - filename = filesList[-1] + if len(validFilelist) > 0: + validFilelist = sorted( validFilelist, key=str.lower ) + return validFilelist[-1] - return filename + return None class DataReader(): @@ -227,7 +195,6 @@ class JRODataReader(DataReader): el "datablock" cada vez que se ejecute el metodo "getData". """ - """ m_BasicHeader = BasicHeader() m_SystemHeader = SystemHeader() @@ -240,19 +207,19 @@ class JRODataReader(DataReader): online = 0 - __startDateTime = None + startDateTime = None - __endDateTime = None + endDateTime = None - __fp = None + fp = None - __fileSizeByHeader = None + fileSizeByHeader = None - __pathList = [] + pathList = [] - __filenameList = [] + filenameList = [] - __fileIndex = None + fileIndex = None filename = None @@ -262,40 +229,45 @@ class JRODataReader(DataReader): basicHeaderSize = 24 - __dataType = None + dataType = None - __blocksize = 0 + blocksize = 0 datablock = None - __datablockIndex = None + datablockIndex = None - __pts2read = 0 + pts2read = 0 #Parametros para el procesamiento en linea - __year = 0 + year = 0 + + doy = 0 - __doy = 0 + set = 0 - __set = 0 + ext = None - __ext = None + path = None - __path = None + optchar = None - __delay = 60 #seconds + delay = 7 #seconds - __nTries = 3 #quantity tries + nTries = 3 #quantity tries - __nFiles = 3 #number of files for searching + nFiles = 3 #number of files for searching + + pts2read = 0 + + blocksize = 0 + + utc = 0 - __pts2read = 0 - __blocksize = 0 - __utc = 0 nBlocks = 0 - """ + #speed of light - __c = 3E8 + c = 3E8 def __init__(self, m_DataObj=None): """ @@ -319,109 +291,28 @@ class JRODataReader(DataReader): Return: None """ - if m_DataObj == None: - m_DataObj = JROData() - if not(isinstance(m_DataObj, JROData)): - raise ValueError, "in JRODataReader, m_DataObj must be an class object" - - self.m_DataObj = m_DataObj - - self.m_BasicHeader = BasicHeader() - - self.m_SystemHeader = SystemHeader() - - self.m_RadarControllerHeader = RadarControllerHeader() - - self.m_ProcessingHeader = ProcessingHeader() - - self.__fp = None - - self.__fileIndex = None - - self.__startDateTime = None - - self.__endDateTime = None - - self.__dataType = None - - self.__fileSizeByHeader = 0 - - self.__pathList = [] - - self.filenameList = [] - - self.__lastUTTime = 0 - - self.__maxTimeStep = 30 - - self.__flagIsNewFile = 0 - - self.__ippSeconds = 0 - - self.flagResetProcessing = 0 - - self.flagIsNewBlock = 0 - - self.noMoreFiles = 0 - - self.nReadBlocks = 0 - - self.online = 0 - - self.filename = None - - self.fileSize = None - - self.firstHeaderSize = 0 - - self.basicHeaderSize = 24 - - self.idProfile = 0 - - self.datablock = None - - self.__datablockIndex = 9999 - - self.__delay = 7 #seconds - self.__nTries = 3 #quantity tries - self.__nFiles = 3 #number of files for searching - self.__year = 0 - self.__doy = 0 - self.__set = 0 - self.__ext = None - self.__path = None - self.__blocksize = 0 - self.__utc = 0 - self.nBlocks = 0 - - self.__pts2read = 0 - self.__pts2read_SelfSpectra = 0 - self.__pts2read_CrossSpectra = 0 - self.__pts2read_DCchannels = 0 - self.__blocksize = 0 - - self.__format = None + raise ValueError, "This class can't be instanced" def __rdSystemHeader(self, fp=None): if fp == None: - fp = self.__fp + fp = self.fp self.m_SystemHeader.read(fp) def __rdRadarControllerHeader(self, fp=None): if fp == None: - fp = self.__fp + fp = self.fp self.m_RadarControllerHeader.read(fp) def __rdProcessingHeader(self, fp=None): if fp == None: - fp = self.__fp + fp = self.fp self.m_ProcessingHeader.read(fp) @@ -429,10 +320,9 @@ class JRODataReader(DataReader): def __rdBasicHeader(self, fp=None): if fp == None: - fp = self.__fp + fp = self.fp self.m_BasicHeader.read(fp) - def __readFirstHeader(self): """ @@ -444,14 +334,14 @@ class JRODataReader(DataReader): self.m_RadarControllerHeader self.m_ProcessingHeader self.firstHeaderSize - self.__heights - self.__dataType - self.__fileSizeByHeader - self.__ippSeconds + self.heights + self.dataType + self.fileSizeByHeader + self.ippSeconds self.nChannels self.nPairs - self.__pts2read_SelfSpectra - self.__pts2read_CrossSpectra + self.pts2read_SelfSpectra + self.pts2read_CrossSpectra Return: None @@ -488,36 +378,12 @@ class JRODataReader(DataReader): step = self.m_ProcessingHeader.deltaHeight xf = xi + self.m_ProcessingHeader.numHeights*step - self.__heights = numpy.arange(xi, xf, step) - self.__dataType = tmp - self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1) - self.__ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.__c - - if self.__format == "jicamarca": - self.__pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels - self.__blocksize = self.__pts2read - - elif self.__format == "pdata": - self.nChannels = 0 - self.nPairs = 0 - - for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ): - if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]: - self.nChannels = self.nChannels + 1 - else: - self.nPairs = self.nPairs + 1 - - pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights - self.__pts2read_SelfSpectra = int( pts2read * self.nChannels ) - self.__pts2read_CrossSpectra = int( pts2read * self.nPairs ) - self.__pts2read_DCchannels = int( self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels ) - - self.__blocksize = self.__pts2read_SelfSpectra + self.__pts2read_CrossSpectra + self.__pts2read_DCchannels - - self.m_DataObj.nChannels = self.nChannels - self.m_DataObj.nPairs = self.nPairs - + self.heights = numpy.arange(xi, xf, step) + self.dataType = tmp + self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1) + self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c + self.getBlockDimension() def __setNextFileOnline(self): """ @@ -526,11 +392,11 @@ class JRODataReader(DataReader): siguientes. Affected: - self.__flagNewFile + self.flagIsNewFile self.filename self.fileSize - self.__fp - self.__set + self.fp + self.set self.flagNoMoreFiles Return: @@ -546,20 +412,20 @@ class JRODataReader(DataReader): notFirstTime_flag = False fileOk_flag = False changeDir_flag = False - self.__flagIsNewFile = 0 + self.flagIsNewFile = 0 while( True ): #este loop permite llevar la cuenta de intentos, de files y carpetas, #si no encuentra alguno sale del bucle countFiles += 1 - if countFiles > (self.__nFiles + 1): + if countFiles > (self.nFiles + 1): break - self.__set += 1 + self.set += 1 - if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta - self.__set = 0 - self.__doy += 1 + if countFiles > self.nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta + self.set = 0 + self.doy += 1 changeDir_flag = True file = None @@ -567,18 +433,18 @@ class JRODataReader(DataReader): fileOk_flag = False #busca el 1er file disponible - file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext ) + file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext ) if file == None: if notFirstTime_flag: #si no es la primera vez que busca el file entonces no espera y busca for el siguiente file print "\tsearching next \"%s\" file ..." % ( filename ) continue - else: #si es la primera vez que busca el file entonces espera self.__nTries veces hasta encontrarlo o no - for nTries in range( self.__nTries ): + else: #si es la primera vez que busca el file entonces espera self.nTries veces hasta encontrarlo o no + for nTries in range( self.nTries ): print "\twaiting new \"%s\" file, try %03d ..." % ( filename, nTries+1 ) - time.sleep( self.__delay ) + time.sleep( self.delay ) - file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext ) + file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext ) if file != None: fileOk_flag = True break @@ -604,9 +470,9 @@ class JRODataReader(DataReader): changeDir_flag = False continue - for nTries in range( self.__nTries ): + for nTries in range( self.nTries ): print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 ) - time.sleep( self.__delay ) + time.sleep( self.delay ) currentSize = os.path.getsize( file ) neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize @@ -624,15 +490,15 @@ class JRODataReader(DataReader): if fileOk_flag: self.fileSize = os.path.getsize( file ) self.filename = file - self.__flagIsNewFile = 1 - if self.__fp != None: self.__fp.close() - self.__fp = open(file) + self.flagIsNewFile = 1 + if self.fp != None: self.fp.close() + self.fp = open(file) self.noMoreFiles = 0 print 'Setting the file: %s' % file else: self.fileSize = 0 self.filename = None - self.__fp = None + self.fp = None self.noMoreFiles = 1 print 'No more Files' @@ -644,11 +510,11 @@ class JRODataReader(DataReader): Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida Affected: - self.__flagIsNewFile - self.__fileIndex + self.flagIsNewFile + self.fileIndex self.filename self.fileSize - self.__fp + self.fp Return: 0 : si un determinado file no puede ser abierto @@ -657,17 +523,17 @@ class JRODataReader(DataReader): Excepciones: Si un determinado file no puede ser abierto """ - idFile = self.__fileIndex + idFile = self.fileIndex while(True): idFile += 1 - if not(idFile < len(self.__filenameList)): + if not(idFile < len(self.filenameList)): self.flagNoMoreFiles = 1 print 'No more Files' return 0 - filename = self.__filenameList[idFile] + filename = self.filenameList[idFile] fileSize = os.path.getsize(filename) try: @@ -684,11 +550,11 @@ class JRODataReader(DataReader): break - self.__flagNewFile = 1 - self.__fileIndex = idFile + self.flagIsNewFile = 1 + self.fileIndex = idFile self.filename = filename self.fileSize = fileSize - self.__fp = fp + self.fp = fp print 'Setting the file: %s'%self.filename @@ -710,8 +576,8 @@ class JRODataReader(DataReader): 0 : Si no hay files disponibles 1 : Si hay mas files disponibles """ - if self.__fp != None: - self.__fp.close() + if self.fp != None: + self.fp.close() if self.online: newFile = self.__setNextFileOnline() @@ -742,13 +608,13 @@ class JRODataReader(DataReader): 0 : Si el file no tiene un Basic Header que pueda ser leido 1 : Si se pudo leer el Basic Header """ - if self.__fp == None: + if self.fp == None: return 0 - if self.__flagIsNewFile: + if self.flagIsNewFile: return 1 - currentSize = self.fileSize - self.__fp.tell() + currentSize = self.fileSize - self.fp.tell() neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize #If there is enough data setting new data block @@ -758,196 +624,49 @@ class JRODataReader(DataReader): #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online: - for nTries in range( self.__nTries ): + for nTries in range( self.nTries ): - fpointer = self.__fp.tell() - self.__fp.close() + fpointer = self.fp.tell() + self.fp.close() print "\tWaiting for the next block, try %03d ..." % (nTries+1) - time.sleep( self.__delay ) + time.sleep( self.delay ) - self.__fp = open( self.filename, 'rb' ) - self.__fp.seek( fpointer ) + self.fp = open( self.filename, 'rb' ) + self.fp.seek( fpointer ) self.fileSize = os.path.getsize( self.filename ) - currentSize = self.fileSize - self.__fp.tell() + currentSize = self.fileSize - self.fp.tell() neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize if ( currentSize >= neededSize ): - self.__rdBasicHeader() + self.rdBasicHeader() return 1 #Setting new file if not( self.__setNextFile() ): return 0 - deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this + deltaTime = self.m_BasicHeader.utc - self.lastUTTime # check this self.flagResetProcessing = 0 - if deltaTime > self.__maxTimeStep: + if deltaTime > self.maxTimeStep: self.flagResetProcessing = 1 #self.nReadBlocks = 0 return 1 - - def __readBlockVoltage(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.__datablockIndex - self.datablock - self.__flagIsNewFile - self.idProfile - self.flagIsNewBlock - self.nReadBlocks - - Exceptions: - Si un bloque leido no es un bloque valido - """ - blockOk_flag = False - fpointer = self.__fp.tell() - - junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read ) - - if self.online: - if junk.size != self.__blocksize: - for nTries in range( self.__nTries ): - print "\tWaiting for the next block, try %03d ..." % (nTries+1) - time.sleep( self.__delay ) - self.__fp.seek( fpointer ) - fpointer = self.__fp.tell() - junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read ) - if junk.size == self.__blocksize: - blockOk_flag = True - break - - if not( blockOk_flag ): - return 0 - - try: - junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) ) - except: - print "Data file %s is invalid" % self.filename - return 0 - - self.datablock = junk['real'] + junk['imag']*1j - - self.__datablockIndex = 0 - self.__flagIsNewFile = 0 - self.idProfile = 0 - self.flagIsNewBlock = 1 - - self.nReadBlocks += 1 - self.nBlocks += 1 - - return 1 - - - def __readBlockSpectra(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.__datablockIndex - self.__flagIsNewFile - self.flagIsNewBlock - self.nReadBlocks - 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.__dataType[0], self.__pts2read_SelfSpectra ) - cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra ) - dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) ) - - if self.online: - if (spc.size + cspc.size + dc.size) != self.__blocksize: - for nTries in range( self.__nTries ): - #nTries = 0 - #while( nTries < self.__nTries ): - #nTries += 1 - print "\tWaiting for the next block, try %03d ..." % (nTries+1) - time.sleep( self.__delay ) - self.__fp.seek( fpointer ) - fpointer = self.__fp.tell() - spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra ) - cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra ) - dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) ) - - if (spc.size + cspc.size + dc.size) == self.__blocksize: - blockOk_flag = True - break - #if (spc.size + cspc.size + dc.size) == self.__blocksize: - # nTries = 0 - # break - if not( blockOk_flag ): - return 0 - #if nTries > 0: - # return 0 + def getBlockDimension(self): - try: - spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D - cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D - dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D - except: - print "Data file %s is invalid" % self.filename - return 0 - - if not( self.m_ProcessingHeader.shif_fft ): - spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones - cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones + raise ValueError, "No implemented" + + def hasNotDataInBuffer(self): - spc = numpy.transpose( spc, (0,2,1) ) - cspc = numpy.transpose( cspc, (0,2,1) ) - #dc = numpy.transpose(dc, (0,2,1)) - - self.__data_spc = spc - self.__data_cspc = cspc['real'] + cspc['imag']*1j - self.__data_dc = dc['real'] + dc['imag']*1j - - self.datablock_id = 0 - self.__flagIsNewFile = 0 - self.flagIsNewBlock = 1 - - self.nReadBlocks += 1 - self.nBlocks += 1 - - return 1 - - - def __hasNotDataInBuffer(self): - if self.__format == "jicamarca": - if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock: - return 1 - else: return 0 + raise ValueError, "Not implemented" - return 1 - - def __searchFilesOnLine( self, path, startDateTime=None, ext = ".pdata" ): + def __searchFilesOnLine( self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = ".pdata" ): """ Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y devuelve el archivo encontrado ademas de otros datos. @@ -965,45 +684,64 @@ class JRODataReader(DataReader): directory : eL directorio donde esta el file encontrado """ - print "Searching files ..." - + print "Searching files ..." + dirList = [] - directory = None - - if startDateTime == None: - for thisPath in os.listdir(path): - if os.path.isdir( os.path.join(path,thisPath) ): - dirList.append( thisPath ) - - dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted - if len(dirList) > 0 : - directory = dirList[-1] #me quedo con el ultimo directorio de una carpeta - else: - year = startDateTime.timetuple().tm_year - doy = startDateTime.timetuple().tm_yday + for thisPath in os.listdir(path): + if os.path.isdir(os.path.join(path,thisPath)): + dirList.append(thisPath) - doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas - if os.path.isdir( os.path.join(path,doyPath) ): - directory = doyPath + pathList = dirList + + if startDateTime != None: + pathList = [] + thisDateTime = startDateTime + if endDateTime == None: endDateTime = startDateTime - doyPath = doyPath.lower() #caso del nombre en minusculas - if os.path.isdir( os.path.join(path,doyPath) ): - directory = doyPath + while(thisDateTime <= endDateTime): + year = thisDateTime.timetuple().tm_year + doy = thisDateTime.timetuple().tm_yday + + match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy)) + if len(match) == 0: + thisDateTime += datetime.timedelta(1) + continue + + pathList.append(os.path.join(path,match[0], expLabel)) + thisDateTime += datetime.timedelta(1) + + + directory = pathList[-1] if directory == None: return 0, 0, 0, None, None - filename = getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext ) - + + nTries = 0 + while True: + if nTries >= self.nTries: + break + filename = getlastFileFromPath(directory, ext ) + + if filename != None: + break + + print "Waiting %d seconds for the first file with extension (%s) on %s..." %(self.delay, ext, directory) + time.sleep(self.delay) + nTries += 1 + if filename == None: - return 0, 0, 0, None, None + return None, None, None, None, None - year = int( directory[-7:-3] ) - doy = int( directory[-3:] ) - ln = len( ext ) - set = int( filename[-ln-3:-ln] ) + if not(self.__verifyFile(os.path.join(directory, filename))): + print "The file %s hasn't enough data" % filename + return None, None, None, None, None + + year = int( filename[1:5] ) + doy = int( filename[5:8] ) + set = int( filename[8:11] ) - return year, doy, set, filename, directory + return directory, filename, year, doy, set def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"): @@ -1045,7 +783,7 @@ class JRODataReader(DataReader): Variables afectadas: - self.__filenameList: Lista de archivos (ruta completa) que la clase utiliza + self.filenameList: Lista de archivos (ruta completa) que la clase utiliza como fuente para leer los bloque de datos, si se termina de leer todos los bloques de datos de un determinado archivo se pasa al siguiente archivo de la lista. @@ -1089,14 +827,14 @@ class JRODataReader(DataReader): if isThisFileinRange(filename, startUtSeconds, endUtSeconds): filenameList.append(filename) - self.__filenameList = filenameList + self.filenameList = filenameList return pathList, filenameList - def __initFilesOnline( self, path, dirfilename, filename ): + def __verifyFile( self, filename ): """ - Verifica que el primer file tenga una data valida, para ello leo el 1er bloque + Verifica que el filename tenga data valida, para ello leo el 1er bloque del file, si no es un file valido espera una cierta cantidad de tiempo a que lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo devuelve 0 caso contrario devuelve 1 @@ -1109,14 +847,12 @@ class JRODataReader(DataReader): 1 : file valido para ser leido """ m_BasicHeader = BasicHeader() - - file = os.path.join( path, dirfilename, filename ) - for nTries in range( self.__nTries+1 ): + for nTries in range( self.nTries+1 ): try: - fp = open( file,'rb' ) #lectura binaria + fp = open( filename,'rb' ) #lectura binaria except: - raise IOError, "The file %s can't be opened" % (file) + raise IOError, "The file %s can't be opened" % (filename) try: m_BasicHeader.read(fp) @@ -1128,11 +864,11 @@ class JRODataReader(DataReader): if m_BasicHeader.size > 24: break - if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar + if nTries >= self.nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar break - print '\twaiting for new block of file %s: try %02d' % ( file, nTries ) - time.sleep( self.__delay ) + print '\twaiting for new block of file %s: try %02d' % ( filename, nTries ) + time.sleep( self.delay ) if m_BasicHeader.size <= 24: return 0 @@ -1146,7 +882,7 @@ class JRODataReader(DataReader): Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos que coincidan con los parametros especificados; esta lista de archivos son almacenados en - self.__filenameList. + self.filenameList. Input: path : Directorios donde se ubican los datos a leer. Dentro de este @@ -1179,66 +915,36 @@ class JRODataReader(DataReader): self.endYear self.startDoy self.endDoy - self.__pathList - self.__filenameList + self.pathList + self.filenameList self.online """ + + if ext == None: + ext = self.ext + if online: - fileOK_flag = False - subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday ) - file = os.path.join( path, subfolder ) - - for nTries in range( self.__nTries+1 ): #espera por el 1er file - year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext ) - - if filename != None: - if isFileOK( os.path.join( path,dirfilename,filename ) ): - fileOK_flag = True - break - - if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar - break - - print "Searching first file in \"%s\", try %03d ..." % ( file, nTries+1 ) - time.sleep( self.__delay ) - - if not( fileOK_flag ): #filename == None: - print "No files on line or invalid first file" + + doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext) + + if doypath == None: return 0 - - if self.__initFilesOnline( path, dirfilename, filename ) == 0: - print "The file %s hasn't enough data" % filename - return 0 - - self.__year = year - self.__doy = doy - self.__set = set - 1 - self.__path = path + + self.year = year + self.doy = doy + self.set = set - 1 + self.path = path else: - pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext ) - self.__fileIndex = -1 - self.__pathList = pathList + pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext) + self.fileIndex = -1 + self.pathList = pathList self.filenameList = filenameList self.online = online - self.__ext = ext + self.ext = ext ext = ext.lower() - - if ext == '.hdf5': - print 'call hdf5 library' - return 0 - - elif ext == '.r': - self.__format = 'jicamarca' - - elif ext == '.pdata': - self.__format = 'pdata' - - else: - print 'unknow format !!!' - return 0 if not( self.__setNextFile() ): if (startDateTime != None) and (endDateTime != None): @@ -1264,7 +970,7 @@ class JRODataReader(DataReader): self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy() self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy() self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy() - self.m_DataObj.dataType = self.__dataType + self.m_DataObj.dataType = self.dataType return 1 @@ -1275,23 +981,22 @@ class JRODataReader(DataReader): mas bloques disponibles en el archivo actual salta al siguiente. Affected: - self.__lastUTTime + self.lastUTTime Return: None """ if not(self.__setNewBlock()): return 0 - - if self.__format == "jicamarca": - self.__readBlockVoltage() - - elif self.__format == "pdata": - self.__readBlockSpectra() - self.__lastUTTime = self.m_BasicHeader.utc + self.readBlock() + + self.lastUTTime = self.m_BasicHeader.utc return 1 + def readBlock(self): + + raise ValueError, "This method has not been implemented" def getData( self ): """ @@ -1306,73 +1011,17 @@ class JRODataReader(DataReader): buffer. Si no hay mas archivos a leer retorna None. Variables afectadas: - self.m_Voltage - self.__datablockIndex + self.m_DataObj + self.datablockIndex Affected: - self.m_Voltage - self.__datablockIndex + self.m_DataObj + self.datablockIndex self.flagNoContinuousBlock - self.__flagNewBlock + self.flagNewBlock """ - if self.noMoreFiles: return 0 - - self.flagResetProcessing = 0 - self.flagIsNewBlock = 0 - - if self.__hasNotDataInBuffer(): - - if not( self.readNextBlock() ): - self.__setNextFile() - return 0 - - self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy() - self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy() - self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy() - self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy() - self.m_DataObj.heights = self.__heights - self.m_DataObj.dataType = self.__dataType - - if self.noMoreFiles == 1: - print 'Process finished' - return 0 - - #data es un numpy array de 3 dmensiones (perfiles, alturas y canales) - if self.__format == "jicamarca": - if self.datablock == None: - self.m_Voltage.flagNoData = True - return 0 - - time = self.m_BasicHeader.utc + self.__datablockIndex * self.__ippSeconds - self.__utc = time - #self.m_DataObj.m_BasicHeader.utc = time - - self.m_DataObj.flagNoData = False - self.m_DataObj.flagResetProcessing = self.flagResetProcessing - - self.m_DataObj.data = self.datablock[self.__datablockIndex,:,:] - self.m_DataObj.idProfile = self.idProfile - - self.__datablockIndex += 1 - self.idProfile += 1 - - elif self.__format == "pdata": - if self.__data_dc == None: - self.m_Voltage.flagNoData = True - return 0 - - self.m_DataObj.flagNoData = False - self.m_DataObj.flagResetProcessing = self.flagResetProcessing - - self.m_DataObj.data_spc = self.__data_spc - self.m_DataObj.data_cspc = self.__data_cspc - self.m_DataObj.data_dc = self.__data_dc - - else: - return 0 - - return 1 #self.m_Voltage.data + raise ValueError, "This method has not been implemented" class JRODataWriter(DataWriter): @@ -1386,7 +1035,7 @@ class JRODataWriter(DataWriter): Inicializador de la clase VoltageWriter para la escritura de datos de espectros. Affected: - self.m_Voltage + self.m_DataObj self.m_BasicHeader self.m_SystemHeader self.m_RadarControllerHeader @@ -1397,33 +1046,35 @@ class JRODataWriter(DataWriter): if m_Voltage == None: m_Voltage = Voltage() - self.m_Voltage = m_Voltage + self.m_DataObj = m_Voltage - self.__path = None + self.path = None - self.__fp = None + self.fp = None - self.__format = None + self.format = None - self.__blocksCounter = 0 + self.blocksCounter = 0 - self.__setFile = None + self.setFile = None - self.__flagIsNewFile = 1 + self.flagIsNewFile = 1 - self.__dataType = None + self.dataType = None self.datablock = None - self.__datablockIndex = 0 + self.datablockIndex = 0 - self.__ext = None + self.ext = None - self.__shapeBuffer = None + self.shapeBuffer = None - self.__shape_spc_Buffer = None - self.__shape_cspc_Buffer = None - self.__shape_dc_Buffer = None + self.shape_spc_Buffer = None + + self.shape_cspc_Buffer = None + + self.shape_dc_Buffer = None self.nWriteBlocks = 0 @@ -1441,9 +1092,11 @@ class JRODataWriter(DataWriter): self.m_ProcessingHeader = ProcessingHeader() - self.__data_spc = None - self.__data_cspc = None - self.__data_dc = None + self.data_spc = None + + self.data_cspc = None + + self.data_dc = None def __writeFirstHeader(self): @@ -1460,7 +1113,7 @@ class JRODataWriter(DataWriter): self.__wrSystemHeader() self.__wrRadarControllerHeader() self.__wrProcessingHeader() - self.__dataType = self.m_DataObj.dataType + self.dataType = self.m_DataObj.dataType def __writeBasicHeader(self, fp=None): @@ -1471,7 +1124,7 @@ class JRODataWriter(DataWriter): None """ if fp == None: - fp = self.__fp + fp = self.fp self.m_BasicHeader.write(fp) @@ -1484,7 +1137,7 @@ class JRODataWriter(DataWriter): None """ if fp == None: - fp = self.__fp + fp = self.fp self.m_SystemHeader.write(fp) @@ -1497,7 +1150,7 @@ class JRODataWriter(DataWriter): None """ if fp == None: - fp = self.__fp + fp = self.fp self.m_RadarControllerHeader.write(fp) @@ -1510,7 +1163,7 @@ class JRODataWriter(DataWriter): None """ if fp == None: - fp = self.__fp + fp = self.fp self.m_ProcessingHeader.write(fp) @@ -1521,20 +1174,20 @@ class JRODataWriter(DataWriter): Affected: self.filename - self.__subfolder - self.__fp - self.__setFile - self.__flagIsNewFile + self.subfolder + self.fp + self.setFile + self.flagIsNewFile Return: 0 : Si el archivo no puede ser escrito 1 : Si el archivo esta listo para ser escrito """ - ext = self.__ext - path = self.__path + ext = self.ext + path = self.path - if self.__fp != None: - self.__fp.close() + if self.fp != None: + self.fp.close() timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc ) # utc from m_Voltage subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday) @@ -1542,7 +1195,7 @@ class JRODataWriter(DataWriter): tmp = os.path.join( path, subfolder ) if not( os.path.exists(tmp) ): os.mkdir(tmp) - self.__setFile = -1 #inicializo mi contador de seteo + self.setFile = -1 #inicializo mi contador de seteo else: filesList = os.listdir( tmp ) if len( filesList ) > 0: @@ -1552,34 +1205,33 @@ class JRODataWriter(DataWriter): # 0 1234 567 89A BCDE (hex) # D 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 + self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file else: - self.__setFile = -1 + self.setFile = -1 else: - self.__setFile = -1 #inicializo mi contador de seteo + self.setFile = -1 #inicializo mi contador de seteo - setFile = self.__setFile + setFile = self.setFile setFile += 1 - - if self.__format == "jicamarca": - shead = "D" - elif self.__format == "pdata": - shead = "P" - file = '%s%4.4d%3.3d%3.3d%s' % ( shead, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext ) + 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.__blocksCounter = 0 + self.blocksCounter = 0 #guardando atributos self.filename = filename - self.__subfolder = subfolder - self.__fp = fp - self.__setFile = setFile - self.__flagIsNewFile = 1 + self.subfolder = subfolder + self.fp = fp + self.setFile = setFile + self.flagIsNewFile = 1 print 'Writing the file: %s'%self.filename @@ -1596,13 +1248,13 @@ class JRODataWriter(DataWriter): 0 : si no pudo escribir nada 1 : Si escribio el Basic el First Header """ - if self.__fp == None: + if self.fp == None: self.__setNextFile() - if self.__flagIsNewFile: + if self.flagIsNewFile: return 1 - if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile: + if self.blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile: self.__writeBasicHeader() return 1 @@ -1612,83 +1264,6 @@ class JRODataWriter(DataWriter): return 1 - def __writeVoltageBlock(self): - """ - Escribe el buffer en el file designado - - Affected: - self.__datablockIndex - self.__flagIsNewFile - self.flagIsNewBlock - self.nWriteBlocks - self.__blocksCounter - - Return: None - """ - data = numpy.zeros( self.__shapeBuffer, self.__dataType ) - - data['real'] = self.datablock.real - data['imag'] = self.datablock.imag - - data = data.reshape( (-1) ) - - data.tofile( self.__fp ) - - self.datablock.fill(0) - self.__datablockIndex = 0 - self.__flagIsNewFile = 0 - self.flagIsNewBlock = 1 - self.nWriteBlocks += 1 - self.__blocksCounter += 1 - - - def __writeSpectraBlock(self): - """ - Escribe el buffer en el file designado - - Affected: - self.__data_spc - self.__data_cspc - self.__data_dc - self.__flagIsNewFile - self.flagIsNewBlock - self.nWriteBlocks - self.__blocksCounter - - Return: None - """ - spc = numpy.transpose( self.__data_spc, (0,2,1) ) - if not( self.m_ProcessingHeader.shif_fft ): - spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones - data = spc.reshape((-1)) - data.tofile(self.__fp) - - data = numpy.zeros( self.__shape_cspc_Buffer, self.__dataType ) - cspc = numpy.transpose( self.__data_cspc, (0,2,1) ) - if not( self.m_ProcessingHeader.shif_fft ): - cspc = numpy.roll( cspc, self.m_ProcessingHeader.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) - - data = numpy.zeros( self.__shape_dc_Buffer, self.__dataType ) - dc = self.__data_dc - data['real'] = dc.real - data['imag'] = dc.imag - data = data.reshape((-1)) - data.tofile(self.__fp) - - self.__data_spc.fill(0) - self.__data_cspc.fill(0) - self.__data_dc.fill(0) - - self.__flagIsNewFile = 0 - self.flagIsNewBlock = 1 - self.nWriteBlocks += 1 - self.__blocksCounter += 1 - - def writeNextBlock(self): """ Selecciona el bloque siguiente de datos y los escribe en un file @@ -1700,75 +1275,11 @@ class JRODataWriter(DataWriter): if not( self.__setNewBlock() ): return 0 - if self.__format == "jicamarca": - self.__writeVoltageBlock() + self.writeBlock() - if self.__format == "pdata": - self.__writeSpectraBlock() - - return 1 - - - def __hasAllDataInBuffer(self): - if self.__format == "jicamarca": - if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock: - return 1 - else: return 0 - - return 1 - - - def putData(self): - """ - Setea un bloque de datos y luego los escribe en un file - - Affected: - self.flagIsNewBlock - self.__datablockIndex - - Return: - 0 : Si no hay data o no hay mas files que puedan escribirse - 1 : Si se escribio la data de un bloque en un file - """ - self.flagIsNewBlock = 0 - - if self.m_DataObj.flagNoData: - return 0 - - if self.m_DataObj.flagResetProcessing: - if self.__format == "jicamarca": - self.datablock.fill(0) - self.__datablockIndex = 0 - - elif self.__format == "pdata": - self.__data_spc.fill(0) - self.__data_cspc.fill(0) - self.__data_dc.fill(0) - - self.__setNextFile() - - if self.__format == "jicamarca": - self.datablock[self.__datablockIndex,:,:] = self.m_Voltage.data - - elif self.__format == "pdata": - self.__data_spc = self.m_Spectra.data_spc - self.__data_cspc = self.m_Spectra.data_cspc - self.__data_dc = self.m_Spectra.data_dc - - self.__datablockIndex += 1 - - if self.__hasAllDataInBuffer(): - self.__getHeader() - self.writeNextBlock() - - if self.noMoreFiles: - #print 'Process finished' - return 0 - return 1 - - def __getHeader(self): + def getHeader(self): """ Obtiene una copia del First Header @@ -1777,7 +1288,7 @@ class JRODataWriter(DataWriter): self.m_SystemHeader self.m_RadarControllerHeader self.m_ProcessingHeader - self.__dataType + self.dataType Return: None @@ -1786,10 +1297,9 @@ class JRODataWriter(DataWriter): self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy() self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy() self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy() - self.__dataType = self.m_DataObj.dataType - - - def setup(self, path, set=0, ext='.pdata'): + self.dataType = self.m_DataObj.dataType + + def setup(self, path, set=0, ext=None): """ Setea el tipo de formato en la cual sera guardada la data y escribe el First Header @@ -1802,53 +1312,49 @@ class JRODataWriter(DataWriter): 0 : Si no realizo un buen seteo 1 : Si realizo un buen seteo """ - - ext = ext.lower() - if ext == '.hdf5': - print 'call hdf5 library' - return 0 + if ext == None: + ext = self.ext - elif ext == '.r': - format = 'jicamarca' + ext = ext.lower() + + self.path = path + self.setFile = set - 1 + self.ext = ext + self.format = format + self.getHeader() - elif ext == '.pdata': - format = 'pdata' + self.setBlockDimension() - else: - print 'unknow format !!!' + if not( self.__setNextFile() ): + print "There isn't a next file" return 0 - self.__path = path - self.__setFile = set - 1 - self.__ext = ext - self.__format = format - self.__getHeader() + return 1 - if self.__format == "jicamarca": - self.__shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock, - self.m_ProcessingHeader.numHeights, - self.m_SystemHeader.numChannels ) - - self.datablock = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex')) + def hasAllDataInBuffer(self): + + raise ValueError, "Not implemented" - elif self.__format == "pdata": - self.__shape_spc_Buffer = ( self.m_Spectra.nChannels, - self.m_ProcessingHeader.numHeights, - self.m_ProcessingHeader.profilesPerBlock - ) + def setBlockDimension(self): + + raise ValueError, "Not implemented" + + def writeBlock(self): + + raise ValueError, "No implemented" - self.__shape_cspc_Buffer = ( self.m_Spectra.nPairs, - self.m_ProcessingHeader.numHeights, - self.m_ProcessingHeader.profilesPerBlock - ) + def putData(self): + """ + Setea un bloque de datos y luego los escribe en un file - self.__shape_dc_Buffer = ( self.m_SystemHeader.numChannels, - self.m_ProcessingHeader.numHeights - ) - - if not( self.__setNextFile() ): - print "There isn't a next file" - return 0 + Affected: + self.flagIsNewBlock + self.datablockIndex - return 1 + Return: + 0 : Si no hay data o no hay mas files que puedan escribirse + 1 : Si se escribio la data de un bloque en un file + """ + + raise ValueError, "No implemented" \ No newline at end of file diff --git a/schainpy/IO/SpectraIO.py b/schainpy/IO/SpectraIO.py index c9c3738..97491e4 100644 --- a/schainpy/IO/SpectraIO.py +++ b/schainpy/IO/SpectraIO.py @@ -20,177 +20,7 @@ from Model.Spectra import Spectra from DataIO import JRODataReader from DataIO import JRODataWriter - -def isFileOK(filename): - """ - Determina si la cabecera de un archivo es valido o no, si lo es entonces seria un archivo que podria contener data, - si no seria un archivo invalido - - Return: - True : si es un archivo valido - False : si no es un archivo valido - - Exceptions: - Si al leer la cabecera esta no coincide con el tipo de las variables que la contienen entonces se dispara - una exception - """ - m_BasicHeader = BasicHeader() - m_ProcessingHeader = ProcessingHeader() - m_RadarControllerHeader = RadarControllerHeader() - m_SystemHeader = SystemHeader() - fp = None - - try: - fp = open( filename,'rb' ) #lectura binaria - m_BasicHeader.read(fp) - m_SystemHeader.read(fp) - m_RadarControllerHeader.read(fp) - m_ProcessingHeader.read(fp) - fp.close() - except: - if fp != None: fp.close() - return False - - return True - - -def getlastFileFromPath(pathList,ext): - """ - Depura el pathList 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: - pathList : lista conteniendo todos los filename completos que componen una determinada carpeta - ext : extension de los files contenidos en una carpeta - - Return: - El ultimo file de una determinada carpeta - """ - - filesList = [] - filename = None - - # 0 1234 567 89A BCDE - # P YYYY DDD SSS .ext - - for filename in pathList: - year = filename[1:5] - doy = filename[5:8] - leng = len( ext ) - - if ( filename[-leng:].upper() != ext.upper() ) : continue - if not( isNumber( year ) ) : continue - if not( isNumber( doy ) ) : continue - - filesList.append(filename) - - if len( filesList ) > 0: - filesList = sorted( filesList, key=str.lower ) - filename = filesList[-1] - - return filename - - -def checkForRealPath(path,year,doy,set,ext): - """ - Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path, - Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar - el path exacto de un determinado file. - - Example : - nombre correcto del file es ../RAWDATA/D2009307/P2009307367 - - Entonces la funcion prueba con las siguientes combinaciones - ../RAWDATA/d2009307/p2009307367 - ../RAWDATA/d2009307/P2009307367 - ../RAWDATA/D2009307/p2009307367 - ../RAWDATA/D2009307/P2009307367 - siendo para este caso, la ultima combinacion de letras, identica al file buscado - - Return: - Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file - caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas - para el filename - """ - filepath = None - find_flag = False - filename = None - - for dir in "dD": #barrido por las dos combinaciones posibles de "D" - for fil in "pP": #barrido por las dos combinaciones posibles de "D" - doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D) - filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext (p=d o p=D) - filepath = os.path.join( path, doypath, filename ) #formo el path completo - if os.path.exists( filepath ): #verifico que exista - find_flag = True - break - if find_flag: - break - - if not(find_flag): - return None, filename - - return filepath, filename - -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 en formato Jicamarca(.r) 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. - """ - m_BasicHeader = BasicHeader() - - try: - fp = open( filename,'rb' ) #lectura binaria - except: - raise IOError, "The file %s can't be opened" %(filename) - - if not(m_BasicHeader.read(fp)): - raise IOError, "The file %s has not a valid header" %(filename) - - fp.close() - - if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)): - return 0 - - return 1 +from DataIO import isNumber class SpectraReader( JRODataReader ): @@ -226,9 +56,6 @@ class SpectraReader( JRODataReader ): """ - #speed of light - __c = 3E8 - def __init__(self,m_Spectra=None): """ @@ -243,7 +70,7 @@ class SpectraReader( JRODataReader ): Si este parametro no es pasado se creara uno internamente. Affected: - self.m_Spectra + self.m_DataObj self.m_BasicHeader self.m_SystemHeader self.m_RadarControllerHeader @@ -257,7 +84,7 @@ class SpectraReader( JRODataReader ): if not( isinstance(m_Spectra, Spectra) ): raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object" - self.m_Spectra = m_Spectra + self.m_DataObj = m_Spectra self.m_BasicHeader = BasicHeader() @@ -267,27 +94,27 @@ class SpectraReader( JRODataReader ): self.m_ProcessingHeader = ProcessingHeader() - self.__fp = None + self.fp = None - self.__idFile = None + self.idFile = None - self.__startDateTime = None + self.startDateTime = None - self.__endDateTime = None + self.endDateTime = None - self.__dataType = None + self.dataType = None - self.__fileSizeByHeader = 0 + self.fileSizeByHeader = 0 - self.__pathList = [] + self.pathList = [] self.filenameList = [] - self.__lastUTTime = 0 + self.lastUTTime = 0 - self.__maxTimeStep = 30 + self.maxTimeStep = 30 - self.__flagIsNewFile = 0 + self.flagIsNewFile = 0 self.flagResetProcessing = 0 @@ -307,21 +134,21 @@ class SpectraReader( JRODataReader ): self.fileSize = None - self.__data_spc = None - self.__data_cspc = None - self.__data_dc = None + self.data_spc = None + self.data_cspc = None + self.data_dc = None self.nChannels = 0 self.nPairs = 0 - self.__pts2read_SelfSpectra = 0 - self.__pts2read_CrossSpectra = 0 - self.__pts2read_DCchannels = 0 - self.__blocksize = 0 + self.pts2read_SelfSpectra = 0 + self.pts2read_CrossSpectra = 0 + self.pts2read_DCchannels = 0 + self.blocksize = 0 - self.__datablockIndex = 0 + self.datablockIndex = 0 - self.__ippSeconds = 0 + self.ippSeconds = 0 self.nSelfChannels = 0 @@ -329,147 +156,21 @@ class SpectraReader( JRODataReader ): self.datablock_id = 9999 - self.__delay = 2 #seconds - self.__nTries = 3 #quantity tries - self.__nFiles = 3 #number of files for searching - self.__year = 0 - self.__doy = 0 - self.__set = 0 - self.__ext = None - self.__path = None + self.delay = 2 #seconds + self.nTries = 3 #quantity tries + self.nFiles = 3 #number of files for searching + self.year = 0 + self.doy = 0 + self.set = 0 + self.ext = ".pdata" + self.path = None + self.optchar = "P" self.nBlocks = 0 - - def __rdSystemHeader(self,fp=None): - """ - Lectura del System Header - - Inputs: - fp : file pointer - - Affected: - self.m_SystemHeader - - Return: None - """ - if fp == None: - fp = self.__fp - - self.m_SystemHeader.read( fp ) - - - - def __rdRadarControllerHeader(self,fp=None): - """ - Lectura del Radar Controller Header - - Inputs: - fp : file pointer - - Affected: - self.m_RadarControllerHeader - - Return: None - """ - if fp == None: - fp = self.__fp - - self.m_RadarControllerHeader.read(fp) - - - def __rdProcessingHeader(self,fp=None): - """ - Lectura del Processing Header - - Inputs: - fp : file pointer - - Affected: - self.m_ProcessingHeader - - Return: None - """ - if fp == None: - fp = self.__fp - - self.m_ProcessingHeader.read(fp) - - - def __rdBasicHeader(self,fp=None): - """ - Lectura del Basic Header - Inputs: - fp : file pointer - - Affected: - self.m_BasicHeader - - Return: None - """ - if fp == None: - fp = self.__fp - - self.m_BasicHeader.read(fp) + def hasNotDataInBuffer(self): + return 1 - - def __readFirstHeader(self): - """ - Lectura del First Header, es decir el Basic Header y el Long Header - - Affected: - self.m_BasicHeader - self.m_SystemHeader - self.m_RadarControllerHeader - self.m_ProcessingHeader - self.firstHeaderSize - self.__heights - self.__dataType - self.__fileSizeByHeader - self.__ippSeconds - self.nChannels - self.nPairs - self.__pts2read_SelfSpectra - self.__pts2read_CrossSpectra - - Return: None - """ - self.__rdBasicHeader() - self.__rdSystemHeader() - self.__rdRadarControllerHeader() - self.__rdProcessingHeader() - self.firstHeaderSize = self.m_BasicHeader.size - - data_type = int( numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR) ) - if data_type == 0: - tmp = numpy.dtype([('real',' (self.__nFiles + 1): - break - - self.__set += 1 - - if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta - self.__set = 0 - self.__doy += 1 - changeDir_flag = True - - file = None - filename = None - fileOk_flag = False - - #busca el 1er file disponible - file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext ) - - if file == None: - if notFirstTime_flag: #si no es la primera vez que busca el file entonces no espera y busca for el siguiente file - print "\tsearching next \"%s\" file ..." % ( filename ) - continue - else: #si es la primera vez que busca el file entonces espera self.__nTries veces hasta encontrarlo o no - for nTries in range( self.__nTries ): - print "\twaiting new \"%s\" file, try %03d ..." % ( filename, nTries+1 ) - time.sleep( self.__delay ) - - file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext ) - if file != None: - fileOk_flag = True - break - - if not( fileOk_flag ): #no encontro ningun file valido a leer - notFirstTime_flag = True - continue - - - """countTries = 0 - - #espero hasta encontrar el 1er file disponible - while( True ): - - countTries += 1 - if( countTries >= self.__nTries ): #checkeo que no haya ido mas alla de la cantidad de intentos - break - - file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext ) - if file != None: - break - - if notFirstTime_flag: #este flag me sirve solo para esperar por el 1er file, en lo siguientes no espera solo checkea si existe o no - countTries = self.__nTries - print "\tsearching next \"%s\" file ..." % filename - break - - print "\twaiting new \"%s\" file ..." % filename - time.sleep( self.__delay ) - - if countTries >= self.__nTries: #se realizaron n intentos y no hubo un file nuevo - notFirstTime_flag = True - continue #vuelvo al inico del while principal - """ - - #una vez que se obtuvo el 1er file valido se procede a checkear si si tamanho es suficiente para empezar a leerlo - currentSize = os.path.getsize( file ) - neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize - - #si el tamanho es suficiente entonces deja de buscar - if currentSize > neededSize: - fileOk_flag = True - break - - fileOk_flag = False - #si el file no tiene el tamanho necesario se espera una cierta cantidad de tiempo - #por una cierta cantidad de veces hasta que el contenido del file sea valido - if changeDir_flag: #si al buscar un file cambie de directorio ya no espero y sigo con el siguiente file - print "\tsearching next \"%s\" file ..." % filename - changeDir_flag = False - continue - - for nTries in range( self.__nTries ): - print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 ) - time.sleep( self.__delay ) - - currentSize = os.path.getsize( file ) - neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize - - if currentSize > neededSize: - fileOk_flag = True - break - - if fileOk_flag: #si encontro un file valido sale del bucle y deja de buscar - break - - print "Skipping the file \"%s\" due to this files is empty" % filename - countFiles = 0 - - if fileOk_flag: - self.fileSize = os.path.getsize( file ) #fileSize - self.filename = file#name - self.__flagIsNewFile = 1 - self.__fp = open(file) - self.noMoreFiles = 0 - print 'Setting the file: %s' % file #name - else: - self.fileSize = 0 - self.filename = None - self.__fp = None - self.noMoreFiles = 1 - print 'No more Files' - - return fileOk_flag - - - def __setNextFileOffline( self ): - """ - Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida - - Affected: - self.__flagIsNewFile - self.__idFile - self.filename - self.fileSize - self.__fp - - Return: - 0 : si un determinado file no puede ser abierto - 1 : si el file fue abierto con exito - - Excepciones: - Si un determinado file no puede ser abierto - """ - idFile = self.__idFile - self.__flagIsNewFile = 0 - - while(True): - idFile += 1 - - if not( idFile < len(self.filenameList) ): - self.noMoreFiles = 1 - print 'No more Files' - return 0 - - filename = self.filenameList[idFile] - fileSize = os.path.getsize(filename) - - try: - fp = open( filename, 'rb' ) - except: - raise IOError, "The file %s can't be opened" %filename - - currentSize = fileSize - fp.tell() - neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize - - if (currentSize < neededSize): - print "Skipping the file %s due to it hasn't enough data" %filename - fp.close() - continue - - break - - self.__flagIsNewFile = 1 - self.__idFile = idFile - self.filename = filename - self.fileSize = fileSize - self.__fp = fp - - print 'Setting the file: %s'%self.filename + self.pts2read_SelfSpectra = int( pts2read * self.nChannels ) + self.pts2read_CrossSpectra = int( pts2read * self.nPairs ) + self.pts2read_DCchannels = int( self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels ) - return 1 - - - def __setNextFile( self ): - """ - Determina el siguiente file a leer y si hay uno disponible lee el First Header - - Affected: - self.m_BasicHeader - self.m_SystemHeader - self.m_RadarControllerHeader - self.m_ProcessingHeader - self.firstHeaderSize - - Return: - 0 : Si no hay files disponibles - 1 : Si hay mas files disponibles - """ - if self.__fp != None: - self.__fp.close() - - if self.online: - newFile = self.__setNextFileOnline() - else: - newFile = self.__setNextFileOffline() - - if self.noMoreFiles: - sys.exit(0) - - if not(newFile): - return 0 - - self.__readFirstHeader() - self.nBlocks = 0 - return 1 - - - def __setNewBlock(self): - """ - Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer - - Affected: - self.m_BasicHeader - self.flagResetProcessing - self.ns - - Return: - 0 : Si el file no tiene un Basic Header que pueda ser leido - 1 : Si se pudo leer el Basic Header - """ - if self.__fp == None: - return 0 - - if self.__flagIsNewFile: - return 1 - - currentSize = self.fileSize - self.__fp.tell() - neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize - - #If there is enough data setting new data block - if ( currentSize >= neededSize ): - self.__rdBasicHeader() - return 1 - - #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido - elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online: - for nTries in range( self.__nTries ): - - fpointer = self.__fp.tell() - self.__fp.close() - - print "\tWaiting for the next block, try %03d ..." % (nTries+1) - time.sleep( self.__delay ) - - self.__fp = open( self.filename, 'rb' ) - self.__fp.seek( fpointer ) - - self.fileSize = os.path.getsize( self.filename ) - currentSize = self.fileSize - self.__fp.tell() - neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize - - if ( currentSize >= neededSize ): - self.__rdBasicHeader() - return 1 - - #Setting new file - if not( self.__setNextFile() ): - return 0 + self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels - deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this - - self.flagResetProcessing = 0 - - if deltaTime > self.__maxTimeStep: - self.flagResetProcessing = 1 - #self.nReadBlocks = 0 + self.m_DataObj.nChannels = self.nChannels + self.m_DataObj.nPairs = self.nPairs - return 1 - - - def __readBlock(self): + 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 + (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.__datablockIndex - self.__flagIsNewFile + self.datablockIndex + self.flagIsNewFile self.flagIsNewBlock self.nReadBlocks - self.__data_spc - self.__data_cspc - self.__data_dc + self.data_spc + self.data_cspc + self.data_dc Exceptions: Si un bloque leido no es un bloque valido """ #self.datablock_id = 0 - #self.__flagIsNewFile = 0 + #self.flagIsNewFile = 0 #self.flagIsNewBlock = 1 blockOk_flag = False - fpointer = self.__fp.tell() + fpointer = self.fp.tell() - spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra ) - cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra ) - dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) ) + spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra ) + cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra ) + dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) ) if self.online: - if (spc.size + cspc.size + dc.size) != self.__blocksize: - for nTries in range( self.__nTries ): + if (spc.size + cspc.size + dc.size) != self.blocksize: + for nTries in range( self.nTries ): #nTries = 0 - #while( nTries < self.__nTries ): + #while( nTries < self.nTries ): #nTries += 1 print "\tWaiting for the next block, try %03d ..." % (nTries+1) - time.sleep( self.__delay ) - self.__fp.seek( fpointer ) - fpointer = self.__fp.tell() - spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra ) - cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra ) - dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) ) + time.sleep( self.delay ) + self.fp.seek( fpointer ) + fpointer = self.fp.tell() + spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra ) + cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra ) + dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) ) - if (spc.size + cspc.size + dc.size) == self.__blocksize: + if (spc.size + cspc.size + dc.size) == self.blocksize: blockOk_flag = True break - #if (spc.size + cspc.size + dc.size) == self.__blocksize: + #if (spc.size + cspc.size + dc.size) == self.blocksize: # nTries = 0 # break if not( blockOk_flag ): @@ -871,348 +264,19 @@ class SpectraReader( JRODataReader ): cspc = numpy.transpose( cspc, (0,2,1) ) #dc = numpy.transpose(dc, (0,2,1)) - self.__data_spc = spc - self.__data_cspc = cspc['real'] + cspc['imag']*1j - self.__data_dc = dc['real'] + dc['imag']*1j + self.data_spc = spc + self.data_cspc = cspc['real'] + cspc['imag']*1j + self.data_dc = dc['real'] + dc['imag']*1j self.datablock_id = 0 - self.__flagIsNewFile = 0 + self.flagIsNewFile = 0 self.flagIsNewBlock = 1 self.nReadBlocks += 1 self.nBlocks += 1 return 1 - - - def __hasNotDataInBuffer(self): - #if self.datablock_id >= self.m_ProcessingHeader.profilesPerBlock: - return 1 - - - def __searchFilesOnLine( self, path, startDateTime=None, ext = ".pdata" ): - """ - 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 - startDateTime : punto especifico en el tiempo del cual se requiere la data - ext : extension de los files - - Return: - year : el anho - doy : el numero de dia del anho - set : el set del archivo - filename : el ultimo file de una determinada carpeta - directory : eL directorio donde esta el file encontrado - """ - print "Searching files ..." - - dirList = [] - directory = None - - if startDateTime == None: - for thisPath in os.listdir(path): - if os.path.isdir( os.path.join(path,thisPath) ): - dirList.append( thisPath ) - - dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted - if len(dirList) > 0 : - directory = dirList[-1] #me quedo con el ultimo directorio de una carpeta - else: - year = startDateTime.timetuple().tm_year - doy = startDateTime.timetuple().tm_yday - - doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas - if os.path.isdir( os.path.join(path,doyPath) ): - directory = doyPath - - doyPath = doyPath.lower() #caso del nombre en minusculas - if os.path.isdir( os.path.join(path,doyPath) ): - directory = doyPath - - if directory == None: - return 0, 0, 0, None, None - - filename = getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext ) - - if filename == None: - return 0, 0, 0, None, None - - year = int( directory[-7:-3] ) - doy = int( directory[-3:] ) - ln = len( ext ) - set = int( filename[-ln-3:-ln] ) - - return year, doy, set, filename, directory - - - def __searchFilesOffLine( self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata" ): - """ - Realiza una busqueda de los archivos que coincidan con los parametros - especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda - correcta la estructura de directorios debe ser la siguiente: - - ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext - - [yyyy]: anio - [ddd] : dia del anio - [sss] : set del archivo - - Inputs: - path : Directorio de datos donde se realizara la busqueda. Todos los - ficheros que concidan con el criterio de busqueda seran - almacenados en una lista y luego retornados. - startDateTime : Fecha inicial. Rechaza todos los archivos donde - file end time < startDateTime (objeto datetime.datetime) - - endDateTime : Fecha final. Rechaza todos los archivos donde - file start time > endDateTime (obejto datetime.datetime) - - set : Set del primer archivo a leer. Por defecto None - - expLabel : Nombre del subdirectorio de datos. Por defecto "" - - ext : Extension de los archivos a leer. Por defecto .r - - Return: - - (pathList, filenameList) - - pathList : Lista de directorios donde se encontraron archivos dentro - de los parametros especificados - filenameList : Lista de archivos (ruta completa) que coincidieron con los - parametros especificados. - - Variables afectadas: - - self.filenameList: Lista de archivos (ruta completa) que la clase utiliza - como fuente para leer los bloque de datos, si se termina - de leer todos los bloques de datos de un determinado - archivo se pasa al siguiente archivo de la lista. - """ - print "Searching files ..." - - dirList = [] - for thisPath in os.listdir(path): - if os.path.isdir(os.path.join(path,thisPath)): - dirList.append(thisPath) - - pathList = [] - - thisDateTime = startDateTime - - while(thisDateTime <= endDateTime): - year = thisDateTime.timetuple().tm_year - doy = thisDateTime.timetuple().tm_yday - - match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy)) - if len(match) == 0: - thisDateTime += datetime.timedelta(1) - continue - - pathList.append(os.path.join(path,match[0],expLabel)) - thisDateTime += datetime.timedelta(1) - - startUtSeconds = time.mktime(startDateTime.timetuple()) - endUtSeconds = time.mktime(endDateTime.timetuple()) - - filenameList = [] - for thisPath in pathList: - fileList = glob.glob1(thisPath, "*%s" %ext) - fileList.sort() - for file in fileList: - filename = os.path.join(thisPath,file) - if isThisFileinRange(filename, startUtSeconds, endUtSeconds): - filenameList.append(filename) - - self.filenameList = filenameList - - return pathList, filenameList - - - def __initFilesOnline( self, path, dirfilename, filename ): - """ - Verifica que el primer file tenga una data valida, para ello leo el 1er bloque - del file, si no es un file valido espera una cierta cantidad de tiempo a que - lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo - devuelve 0 caso contrario devuelve 1 - - Affected: - m_BasicHeader - - Return: - 0 : file no valido para ser leido - 1 : file valido para ser leido - """ - m_BasicHeader = BasicHeader() - - file = os.path.join( path, dirfilename, filename ) - - for nTries in range( self.__nTries+1 ): - try: - fp = open( file,'rb' ) #lectura binaria - except: - raise IOError, "The file %s can't be opened" %(file) - - try: - m_BasicHeader.read(fp) - except: - print "The file %s is empty" % filename - - fp.close() - - if m_BasicHeader.size > 24: - break - - if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar - break - - print '\twaiting for new block of file %s: try %02d' % ( file, nTries ) - time.sleep( self.__delay) - - if m_BasicHeader.size <= 24: - return 0 - - return 1 - - - def setup( self, path, startDateTime=None, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ): - """ - setup configura los parametros de lectura de la clase SpectraReader. - - Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos - que coincidan con los parametros especificados; esta lista de archivos son almacenados en - self.filenameList. - - Input: - path : Directorios donde se ubican los datos a leer. Dentro de este - directorio deberia de estar subdirectorios de la forma: - - path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext] - - startDateTime : Fecha inicial. Rechaza todos los archivos donde - file end time < startDatetime (objeto datetime.datetime) - - endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde - file end time < startDatetime (objeto datetime.datetime) - - set : Set del primer archivo a leer. Por defecto None - - expLabel : Nombre del subdirectorio de datos. Por defecto "" - - ext : Extension de los archivos a leer. Por defecto .pdata - - online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas - - Return: - 0 : Si no encuentra files que cumplan con las condiciones dadas - 1 : Si encuentra files que cumplan con las condiciones dadas - - Affected: - self.startUTCSeconds - self.endUTCSeconds - self.startYear - self.endYear - self.startDoy - self.endDoy - self.__pathList - self.filenameList - self.online - """ - if online: - fileOK_flag = False - subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday ) - file = os.path.join( path, subfolder ) - - for nTries in range( self.__nTries+1 ): #espera por el 1er file - year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext ) - - if filename != None: - if isFileOK( os.path.join( path,dirfilename,filename ) ): - fileOK_flag = True - break - - if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar - break - - print "Searching first file in \"%s\", try %03d ..." % ( file, nTries+1 ) - time.sleep( self.__delay ) - - if not( fileOK_flag ): #filename == None: - print "No files on line or invalid first file" - return 0 - - if self.__initFilesOnline( path, dirfilename, filename ) == 0: - print "The file %s hasn't enough data" % filename - return 0 - - self.__year = year - self.__doy = doy - self.__set = set - 1 - self.__path = path - - else: - pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext ) - self.__idFile = -1 - self.__pathList = pathList - self.filenameList = filenameList - - self.online = online - self.__ext = ext - - if not( self.__setNextFile() ): - if (startDateTime != None) and (endDateTime != None): - print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime()) - elif startDateTime != None: - print "No files in : %s" % startDateTime.ctime() - else: - print "No files" - return 0 - - if startDateTime != None: - self.startUTCSeconds = time.mktime(startDateTime.timetuple()) - self.startYear = startDateTime.timetuple().tm_year - self.startDoy = startDateTime.timetuple().tm_yday - - if endDateTime != None: - self.endUTCSeconds = time.mktime(endDateTime.timetuple()) - self.endYear = endDateTime.timetuple().tm_year - self.endDoy = endDateTime.timetuple().tm_yday - #call fillHeaderValues() - to Data Object - - self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy() - self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy() - self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy() - self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy() - self.m_Spectra.dataType = self.__dataType - - return 1 - - def readNextBlock( self ): - """ - Establece un nuevo bloque de datos a leer y los lee, si es que no existiese - mas bloques disponibles en el archivo actual salta al siguiente. - - Affected: - self.__lastUTTime - - Return: None - """ - - if not( self.__setNewBlock() ): - return 0 - - if not( self.__readBlock() ): - return 0 - - self.__lastUTTime = self.m_BasicHeader.utc - - return 1 - - def getData(self): """ Copia el buffer de lectura a la clase "Spectra", @@ -1224,8 +288,8 @@ class SpectraReader( JRODataReader ): 1 : Si hizo una buena copia del buffer Affected: - self.m_Spectra - self.__datablockIndex + self.m_DataObj + self.datablockIndex self.flagResetProcessing self.flagIsNewBlock """ @@ -1233,18 +297,18 @@ class SpectraReader( JRODataReader ): self.flagResetProcessing = 0 self.flagIsNewBlock = 0 - if self.__hasNotDataInBuffer(): + if self.hasNotDataInBuffer(): if not( self.readNextBlock() ): - self.__setNextFile() + self.setNextFile() return 0 - self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy() - self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy() - self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy() - self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy() - self.m_Spectra.heights = self.__heights - self.m_Spectra.dataType = self.__dataType + self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy() + self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy() + self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy() + self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy() + self.m_DataObj.heights = self.heights + self.m_DataObj.dataType = self.dataType if self.noMoreFiles == 1: print 'Process finished' @@ -1252,16 +316,16 @@ class SpectraReader( JRODataReader ): #data es un numpy array de 3 dmensiones (perfiles, alturas y canales) - if self.__data_dc == None: + if self.data_dc == None: self.m_Voltage.flagNoData = True return 0 - self.m_Spectra.flagNoData = False - self.m_Spectra.flagResetProcessing = self.flagResetProcessing + self.m_DataObj.flagNoData = False + self.m_DataObj.flagResetProcessing = self.flagResetProcessing - self.m_Spectra.data_spc = self.__data_spc - self.m_Spectra.data_cspc = self.__data_cspc - self.m_Spectra.data_dc = self.__data_dc + self.m_DataObj.data_spc = self.data_spc + self.m_DataObj.data_cspc = self.data_cspc + self.m_DataObj.data_dc = self.data_dc #call setData - to Data Object #self.datablock_id += 1 @@ -1280,7 +344,7 @@ class SpectraWriter( JRODataWriter ): Inicializador de la clase SpectraWriter para la escritura de datos de espectros. Affected: - self.m_Spectra + self.m_DataObj self.m_BasicHeader self.m_SystemHeader self.m_RadarControllerHeader @@ -1292,27 +356,29 @@ class SpectraWriter( JRODataWriter ): if m_Spectra == None: m_Spectra = Spectra() - self.m_Spectra = m_Spectra - - self.__path = None + self.m_DataObj = m_Spectra - self.__fp = None + self.fp = None - self.__format = None + self.format = None - self.__blocksCounter = 0 + self.blocksCounter = 0 - self.__setFile = None + self.setFile = None - self.__flagIsNewFile = 1 + self.flagIsNewFile = 1 - self.__dataType = None + self.dataType = None - self.__ext = None + self.ext = ".pdata" - self.__shape_spc_Buffer = None - self.__shape_cspc_Buffer = None - self.__shape_dc_Buffer = None + self.path = None + + self.optchar = "P" + + self.shape_spc_Buffer = None + self.shape_cspc_Buffer = None + self.shape_dc_Buffer = None self.nWriteBlocks = 0 @@ -1330,246 +396,81 @@ class SpectraWriter( JRODataWriter ): self.m_ProcessingHeader = ProcessingHeader() - self.__data_spc = None - self.__data_cspc = None - self.__data_dc = None - - 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 - """ - self.__writeBasicHeader() - self.__wrSystemHeader() - self.__wrRadarControllerHeader() - self.__wrProcessingHeader() - self.__dataType = self.m_Spectra.dataType - - - def __writeBasicHeader(self, fp=None): - """ - Escribe solo el Basic header en el file creado - - Return: - None - """ - if fp == None: - fp = self.__fp - - self.m_BasicHeader.write(fp) - - - def __wrSystemHeader(self,fp=None): - """ - Escribe solo el System header en el file creado - - Return: - None - """ - if fp == None: - fp = self.__fp - - self.m_SystemHeader.write(fp) - - - def __wrRadarControllerHeader(self,fp=None): - """ - Escribe solo el RadarController header en el file creado - - Return: - None - """ - if fp == None: - fp = self.__fp - - self.m_RadarControllerHeader.write(fp) - - - def __wrProcessingHeader(self,fp=None): - """ - Escribe solo el Processing header en el file creado - - Return: - None - """ - if fp == None: - fp = self.__fp - - self.m_ProcessingHeader.write(fp) + self.data_spc = None + self.data_cspc = None + self.data_dc = None + def hasAllDataInBuffer(self): + return 1 - def __setNextFile(self): - """ - Determina el siguiente file que sera escrito + def setBlockDimension(self): - Affected: - self.filename - self.__subfolder - self.__fp - self.__setFile - self.__flagIsNewFile + self.shape_spc_Buffer = (self.m_DataObj.nChannels, + self.m_ProcessingHeader.numHeights, + self.m_ProcessingHeader.profilesPerBlock) - Return: - 0 : Si el archivo no puede ser escrito - 1 : Si el archivo esta listo para ser escrito - """ - ext = self.__ext - path = self.__path + self.shape_cspc_Buffer = (self.m_DataObj.nPairs, + self.m_ProcessingHeader.numHeights, + self.m_ProcessingHeader.profilesPerBlock) - if self.__fp != None: - self.__fp.close() - - #if self.m_BasicHeader.size <= 24: return 0 #no existe la suficiente data para ser escrita - - timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra - subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday) + self.shape_dc_Buffer = (self.m_SystemHeader.numChannels, + self.m_ProcessingHeader.numHeights) - tmp = os.path.join( path, subfolder ) - if not( os.path.exists(tmp) ): - os.mkdir(tmp) - self.__setFile = -1 #inicializo mi contador de seteo - else: - filesList = os.listdir( tmp ) - 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) - # P 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 = 'P%4.4d%3.3d%3.3d%s' % ( timeTuple.tm_year, timeTuple.tm_yday, setFile, ext ) - - filename = os.path.join( path, subfolder, file ) - - fp = open(filename,'wb') - - self.__blocksCounter = 0 - - #guardando atributos - self.filename = filename - self.__subfolder = subfolder - self.__fp = fp - self.__setFile = setFile - self.__flagIsNewFile = 1 - - print 'Writing the file: %s'%self.filename - - self.__writeFirstHeader() - - return 1 - - - def __setNewBlock(self): - """ - Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header - - Return: - 0 : si no pudo escribir nada - 1 : Si escribio el Basic el First Header - """ - if self.__fp == None: - self.__setNextFile() - - if self.__flagIsNewFile: - return 1 - - if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile: - self.__writeBasicHeader() - return 1 - - if not( self.__setNextFile() ): - return 0 - - return 1 - - def __writeBlock(self): + def writeBlock(self): """ Escribe el buffer en el file designado Affected: - self.__data_spc - self.__data_cspc - self.__data_dc - self.__flagIsNewFile + self.data_spc + self.data_cspc + self.data_dc + self.flagIsNewFile self.flagIsNewBlock self.nWriteBlocks - self.__blocksCounter + self.blocksCounter Return: None """ - spc = numpy.transpose( self.__data_spc, (0,2,1) ) + spc = numpy.transpose( self.data_spc, (0,2,1) ) if not( self.m_ProcessingHeader.shif_fft ): spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones data = spc.reshape((-1)) - data.tofile(self.__fp) + data.tofile(self.fp) - data = numpy.zeros( self.__shape_cspc_Buffer, self.__dataType ) - cspc = numpy.transpose( self.__data_cspc, (0,2,1) ) + data = numpy.zeros( self.shape_cspc_Buffer, self.dataType ) + cspc = numpy.transpose( self.data_cspc, (0,2,1) ) if not( self.m_ProcessingHeader.shif_fft ): cspc = numpy.roll( cspc, self.m_ProcessingHeader.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) + data.tofile(self.fp) - data = numpy.zeros( self.__shape_dc_Buffer, self.__dataType ) - dc = self.__data_dc + data = numpy.zeros( self.shape_dc_Buffer, self.dataType ) + dc = self.data_dc data['real'] = dc.real data['imag'] = dc.imag data = data.reshape((-1)) - data.tofile(self.__fp) + data.tofile(self.fp) - self.__data_spc.fill(0) - self.__data_cspc.fill(0) - self.__data_dc.fill(0) + self.data_spc.fill(0) + self.data_cspc.fill(0) + self.data_dc.fill(0) - self.__flagIsNewFile = 0 + self.flagIsNewFile = 0 self.flagIsNewBlock = 1 self.nWriteBlocks += 1 - self.__blocksCounter += 1 - - - def writeNextBlock(self): - """ - Selecciona el bloque siguiente de datos y los escribe en un file - - Return: - 0 : Si no hizo pudo escribir el bloque de datos - 1 : Si no pudo escribir el bloque de datos - """ - if not( self.__setNewBlock() ): - return 0 + self.blocksCounter += 1 - self.__writeBlock() - return 1 - - - def __hasAllDataInBuffer(self): - return 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 + self.data_spc + self.data_cspc + self.data_dc Return: 0 : Si no hay data o no hay mas files que puedan escribirse @@ -1577,182 +478,25 @@ class SpectraWriter( JRODataWriter ): """ self.flagIsNewBlock = 0 - if self.m_Spectra.flagNoData: + if self.m_DataObj.flagNoData: return 0 - if self.m_Spectra.flagResetProcessing: - self.__data_spc.fill(0) - self.__data_cspc.fill(0) - self.__data_dc.fill(0) - self.__setNextFile() + if self.m_DataObj.flagResetProcessing: + self.data_spc.fill(0) + self.data_cspc.fill(0) + self.data_dc.fill(0) + self.setNextFile() - self.__data_spc = self.m_Spectra.data_spc - self.__data_cspc = self.m_Spectra.data_cspc - self.__data_dc = self.m_Spectra.data_dc + self.data_spc = self.m_DataObj.data_spc + self.data_cspc = self.m_DataObj.data_cspc + self.data_dc = self.m_DataObj.data_dc if True: - self.__getHeader() + self.getHeader() self.writeNextBlock() if self.noMoreFiles: #print 'Process finished' return 0 - return 1 - - def __getHeader(self): - """ - Obtiene una copia del First Header - - Affected: - self.m_BasicHeader - self.m_SystemHeader - self.m_RadarControllerHeader - self.m_ProcessingHeader - self.__dataType - - Return: - None - """ - self.m_BasicHeader = self.m_Spectra.m_BasicHeader.copy() - self.m_SystemHeader = self.m_Spectra.m_SystemHeader.copy() - self.m_RadarControllerHeader = self.m_Spectra.m_RadarControllerHeader.copy() - self.m_ProcessingHeader = self.m_Spectra.m_ProcessingHeader.copy() - self.__dataType = self.m_Spectra.dataType - - - def __setHeaderByFile(self): - - format = self.__format - header = ['Basic','System','RadarController','Processing'] - - fmtFromFile = None - headerFromFile = None - - - fileTable = self.__configHeaderFile - - if os.access(fileTable, os.R_OK): - import re, string - - f = open(fileTable,'r') - lines = f.read() - f.close() - - #Delete comments into expConfig - while 1: - - startComment = string.find(lines.lower(),'#') - if startComment == -1: - break - endComment = string.find(lines.lower(),'\n',startComment) - lines = string.replace(lines,lines[startComment:endComment+1],'', 1) - - while expFromFile == None: - - currFmt = string.find(lines.lower(),'format="%s"' %(expName)) - nextFmt = string.find(lines.lower(),'format',currFmt+10) - - if currFmt == -1: - break - if nextFmt == -1: - nextFmt = len(lines)-1 - - fmtTable = lines[currFmt:nextFmt] - lines = lines[nextFmt:] - - fmtRead = self.__getValueFromArg(fmtTable,'format') - if fmtRead != format: - continue - fmtFromFile = fmtRead - - lines2 = fmtTable - - while headerFromFile == None: - - currHeader = string.find(lines2.lower(),'header="%s"' %(header)) - nextHeader = string.find(lines2.lower(),'header',currHeader+10) - - if currHeader == -1: - break - if nextHeader == -1: - nextHeader = len(lines2)-1 - - headerTable = lines2[currHeader:nextHeader] - lines2 = lines2[nextHeader:] - - headerRead = self.__getValueFromArg(headerTable,'site') - if not(headerRead in header): - continue - headerFromFile = headerRead - - if headerRead == 'Basic': - self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False) - self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False) - self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False) - self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False) - self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False) - self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False) - self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False) - self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False) - - else: - print "file access denied:%s"%fileTable - sys.exit(0) - - - def setup(self,path,format='pdata'): - """ - 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 - - Return: - 0 : Si no realizo un buen seteo - 1 : Si realizo un buen seteo - """ - if format == 'hdf5': - ext = '.hdf5' - format = 'hdf5' - print 'call hdf5 library' - return 0 - - if format == 'rawdata': - ext = '.r' - format = 'Jicamarca' - - if format == 'pdata': - ext = '.pdata' - format = 'pdata' - - #call to config_headers - #self.__setHeaderByFile() - - self.__path = path - self.__setFile = -1 - self.__ext = ext - self.__format = format - - self.__getHeader() - - self.__shape_spc_Buffer = ( self.m_Spectra.nChannels, - self.m_ProcessingHeader.numHeights, - self.m_ProcessingHeader.profilesPerBlock - ) - - self.__shape_cspc_Buffer = ( self.m_Spectra.nPairs, - self.m_ProcessingHeader.numHeights, - self.m_ProcessingHeader.profilesPerBlock - ) - - self.__shape_dc_Buffer = ( self.m_SystemHeader.numChannels, - self.m_ProcessingHeader.numHeights - ) - - if not( self.__setNextFile() ): - print "There isn't a next file" #"zzzzzzzzzzzz" - return 0 - return 1 \ No newline at end of file diff --git a/schainpy/IO/VoltageIO.py b/schainpy/IO/VoltageIO.py index 00dfb32..8e0bc21 100644 --- a/schainpy/IO/VoltageIO.py +++ b/schainpy/IO/VoltageIO.py @@ -20,177 +20,6 @@ from Model.Voltage import Voltage from IO.DataIO import JRODataReader from IO.DataIO import JRODataWriter -def isFileOK(filename): - """ - Determina si la cabecera de un archivo es valido o no, si lo es entonces seria un archivo que podria contener data, - si no seria un archivo invalido - - Return: - True : si es un archivo valido - False : si no es un archivo valido - - Exceptions: - Si al leer la cabecera esta no coincide con el tipo de las variables que la contienen entonces se dispara - una exception - """ - m_BasicHeader = BasicHeader() - m_ProcessingHeader = ProcessingHeader() - m_RadarControllerHeader = RadarControllerHeader() - m_SystemHeader = SystemHeader() - fp = None - - try: - fp = open( filename,'rb' ) #lectura binaria - m_BasicHeader.read(fp) - m_SystemHeader.read(fp) - m_RadarControllerHeader.read(fp) - m_ProcessingHeader.read(fp) - fp.close() - except: - if fp != None: fp.close() - return False - - return True - - -def getlastFileFromPath(pathList,ext): - """ - Depura el pathList 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: - pathList : lista conteniendo todos los filename completos que componen una determinada carpeta - ext : extension de los files contenidos en una carpeta - - Return: - El ultimo file de una determinada carpeta - """ - - filesList = [] - filename = None - - # 0 1234 567 89A BCDE - # D YYYY DDD SSS .ext - - for filename in pathList: - year = filename[1:5] - doy = filename[5:8] - leng = len( ext ) - - if ( filename[-leng:].upper() != ext.upper() ) : continue - if not( isNumber( year ) ) : continue - if not( isNumber( doy ) ) : continue - - filesList.append(filename) - - if len( filesList ) > 0: - filesList = sorted( filesList, key=str.lower ) - filename = filesList[-1] - - return filename - - -def checkForRealPath(path,year,doy,set,ext): - """ - Por ser Linux Case Sensitive la funcion 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 ../RAWDATA/D2009307/P2009307367 - - Entonces la funcion prueba con las siguientes combinaciones - ../.../d2009307/d2009307367 - ../.../d2009307/D2009307367 - ../.../D2009307/d2009307367 - ../.../D2009307/D2009307367 - siendo para este caso, la ultima combinacion de letras, identica al file buscado - - Return: - Si encuentra la combinacion adecuada devuelve el path completo y el nombre del file - caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas - para el filename - """ - filepath = None - find_flag = False - filename = None - - for dir in "dD": #barrido por las dos combinaciones posibles de "D" - for fil in "dD": #barrido por las dos combinaciones posibles de "D" - doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D) - filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext (p=d o p=D) - filepath = os.path.join( path, doypath, filename ) #formo el path completo - if os.path.exists( filepath ): #verifico que exista - find_flag = True - break - if find_flag: - break - - if not(find_flag): - return None, filename - - return filepath, filename - - -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 en formato Jicamarca(.r) 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. - - """ - m_BasicHeader = BasicHeader() - - try: - fp = open(filename,'rb') - except: - raise IOError, "The file %s can't be opened" %(filename) - - if not(m_BasicHeader.read(fp)): - raise IOError, "The file %s has not a valid header" %(filename) - - fp.close() - - if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)): - return 0 - - return 1 - class VoltageReader(JRODataReader): """ Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura @@ -229,9 +58,6 @@ class VoltageReader(JRODataReader): break """ - - #speed of light - __c = 3E8 def __init__(self,m_Voltage=None): @@ -247,7 +73,7 @@ class VoltageReader(JRODataReader): Si este parametro no es pasado se creara uno internamente. Variables afectadas: - self.m_Voltage + self.m_DataObj self.m_BasicHeader self.m_SystemHeader self.m_RadarControllerHeader @@ -264,7 +90,7 @@ class VoltageReader(JRODataReader): if not(isinstance(m_Voltage, Voltage)): raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object" - self.m_Voltage = m_Voltage + self.m_DataObj = m_Voltage self.m_BasicHeader = BasicHeader() @@ -274,29 +100,29 @@ class VoltageReader(JRODataReader): self.m_ProcessingHeader = ProcessingHeader() - self.__fp = None + self.fp = None - self.__idFile = None + self.idFile = None - self.__startDateTime = None + self.startDateTime = None - self.__endDateTime = None + self.endDateTime = None - self.__dataType = None + self.dataType = None - self.__fileSizeByHeader = 0 + self.fileSizeByHeader = 0 - self.__pathList = [] + self.pathList = [] self.filenameList = [] - self.__lastUTTime = 0 + self.lastUTTime = 0 - self.__maxTimeStep = 30 + self.maxTimeStep = 30 - self.__flagIsNewFile = 0 + self.flagIsNewFile = 0 - self.__ippSeconds = 0 + self.ippSeconds = 0 self.flagResetProcessing = 0 @@ -320,373 +146,48 @@ class VoltageReader(JRODataReader): self.datablock = None - self.__datablockIndex = 9999 - - self.__delay = 7 #seconds - self.__nTries = 3 #quantity tries - self.__nFiles = 3 #number of files for searching - self.__year = 0 - self.__doy = 0 - self.__set = 0 - self.__ext = None - self.__path = None - self.__pts2read = 0 - self.__blocksize = 0 - self.__utc = 0 - self.nBlocks = 0 - - - def __rdSystemHeader(self,fp=None): - if fp == None: - fp = self.__fp - - self.m_SystemHeader.read(fp) - - - def __rdRadarControllerHeader(self,fp=None): - if fp == None: - fp = self.__fp - - self.m_RadarControllerHeader.read(fp) - - - def __rdProcessingHeader(self,fp=None): - if fp == None: - fp = self.__fp - - self.m_ProcessingHeader.read(fp) + self.datablockIndex = 9999 - - def __rdBasicHeader(self,fp=None): + self.delay = 7 #seconds - if fp == None: - fp = self.__fp - - self.m_BasicHeader.read(fp) - - - def __readFirstHeader(self): - """ - Lectura del First Header, es decir el Basic Header y el Long Header - - Affected: - self.m_BasicHeader - self.m_SystemHeader - self.m_RadarControllerHeader - self.m_ProcessingHeader - self.firstHeaderSize - self.__heights - self.__dataType - self.__fileSizeByHeader - self.__ippSeconds - self.__blocksize - self.__pts2read - - Return: None - """ - self.__rdBasicHeader() - self.__rdSystemHeader() - self.__rdRadarControllerHeader() - self.__rdProcessingHeader() - self.firstHeaderSize = self.m_BasicHeader.size - - data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR)) - if data_type == 0: - tmp = numpy.dtype([('real',' (self.__nFiles + 1): - break - - self.__set += 1 - - if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta - self.__set = 0 - self.__doy += 1 - changeDir_flag = True - - file = None - filename = None - fileOk_flag = False - - #busca el 1er file disponible - file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext ) - - if file == None: - if notFirstTime_flag: #si no es la primera vez que busca el file entonces no espera y busca for el siguiente file - print "\tsearching next \"%s\" file ..." % ( filename ) - continue - else: #si es la primera vez que busca el file entonces espera self.__nTries veces hasta encontrarlo o no - for nTries in range( self.__nTries ): - print "\twaiting new \"%s\" file, try %03d ..." % ( filename, nTries+1 ) - time.sleep( self.__delay ) - - file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext ) - if file != None: - fileOk_flag = True - break - - if not( fileOk_flag ): #no encontro ningun file valido a leer despues de haber esperado alguno - notFirstTime_flag = True - continue - - #una vez que se obtuvo el 1er file valido se procede a checkear si si tamanho es suficiente para empezar a leerlo - currentSize = os.path.getsize( file ) - neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize - - #si el tamanho es suficiente entonces deja de buscar - if currentSize > neededSize:# and (neededSize != 0): - fileOk_flag = True - break - - fileOk_flag = False - #si el file no tiene el tamanho necesario se espera una cierta cantidad de tiempo - #por una cierta cantidad de veces hasta que el contenido del file sea valido - if changeDir_flag: #si al buscar un file cambie de directorio ya no espero y sigo con el siguiente file - print "\tsearching next \"%s\" file ..." % filename - changeDir_flag = False - continue - - for nTries in range( self.__nTries ): - print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 ) - time.sleep( self.__delay ) - - currentSize = os.path.getsize( file ) - neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize - - if currentSize > neededSize: - fileOk_flag = True - break - - if fileOk_flag: #si encontro un file valido sale del bucle y deja de buscar - break - - print "Skipping the file \"%s\" due to this files is empty" % filename - countFiles = 0 - - if fileOk_flag: - self.fileSize = os.path.getsize( file ) #fileSize - self.filename = file - self.__flagIsNewFile = 1 - if self.__fp != None: self.__fp.close() - self.__fp = open(file) - self.noMoreFiles = 0 - print 'Setting the file: %s' % file - else: - self.fileSize = 0 - self.filename = None - self.__fp = None - self.noMoreFiles = 1 - print 'No more Files' - - return fileOk_flag - - - def __setNextFileOffline(self): + self.path = None - idFile = self.__idFile - while(True): - - idFile += 1 - - if not(idFile < len(self.filenameList)): - self.noMoreFiles = 1 - print 'No more Files' - return 0 - - filename = self.filenameList[idFile] - fileSize = os.path.getsize(filename) - - try: - fp = open(filename,'rb') - except: - raise IOError, "The file %s can't be opened" %filename - - currentSize = fileSize - fp.tell() - neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize - - if (currentSize < neededSize): - print "Skipping the file %s due to it hasn't enough data" %filename - continue - - break + self.optchar = "D" - self.__flagIsNewFile = 1 - self.__idFile = idFile - self.filename = filename - self.fileSize = fileSize - self.__fp = fp + self.pts2read = 0 - print 'Setting the file: %s'%self.filename + self.blocksize = 0 - return 1 - - - def __setNextFile(self): - """ - Determina el siguiente file a leer y si hay uno disponible lee el First Header - - Affected: - self.m_BasicHeader - self.m_SystemHeader - self.m_RadarControllerHeader - self.m_ProcessingHeader - self.firstHeaderSize - - Return: - 0 : Si no hay files disponibles - 1 : Si hay mas files disponibles - """ - if self.__fp != None: - self.__fp.close() - - if self.online: - newFile = self.__setNextFileOnline() - else: - newFile = self.__setNextFileOffline() + self.utc = 0 - if self.noMoreFiles: - sys.exit(0) - - if not(newFile): - return 0 - - self.__readFirstHeader() self.nBlocks = 0 - return 1 - - def __setNewBlock(self): - """ - Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer - - Affected: - self.m_BasicHeader - self.flagResetProcessing - self.ns - - Return: - 0 : Si el file no tiene un Basic Header que pueda ser leido - 1 : Si se pudo leer el Basic Header - """ - if self.__fp == None: - return 0 - - if self.__flagIsNewFile: - return 1 - - currentSize = self.fileSize - self.__fp.tell() - neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize - - #If there is enough data setting new data block - if ( currentSize >= neededSize ): - self.__rdBasicHeader() + def hasNotDataInBuffer(self): + if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock: return 1 - - #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido - elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online: - for nTries in range( self.__nTries ): - - fpointer = self.__fp.tell() - self.__fp.close() - - print "\tWaiting for the next block, try %03d ..." % (nTries+1) - time.sleep( self.__delay ) - - self.__fp = open( self.filename, 'rb' ) - self.__fp.seek( fpointer ) - - self.fileSize = os.path.getsize( self.filename ) - currentSize = self.fileSize - self.__fp.tell() - neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize + return 0 - if ( currentSize >= neededSize ): - self.__rdBasicHeader() - return 1 - - #Setting new file - if not( self.__setNextFile() ): - return 0 + def getBlockDimension(self): - deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this - - self.flagResetProcessing = 0 - - if deltaTime > self.__maxTimeStep: - self.flagResetProcessing = 1 - #self.nReadBlocks = 0 + self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels + self.blocksize = self.pts2read - return 1 - - - def __readBlock(self): + 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 + 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 @@ -697,9 +198,9 @@ class VoltageReader(JRODataReader): None Affected: - self.__datablockIndex + self.datablockIndex self.datablock - self.__flagIsNewFile + self.flagIsNewFile self.idProfile self.flagIsNewBlock self.nReadBlocks @@ -708,19 +209,19 @@ class VoltageReader(JRODataReader): Si un bloque leido no es un bloque valido """ blockOk_flag = False - fpointer = self.__fp.tell() + fpointer = self.fp.tell() - junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read ) + junk = numpy.fromfile( self.fp, self.dataType, self.pts2read ) if self.online: - if junk.size != self.__blocksize: - for nTries in range( self.__nTries ): + if junk.size != self.blocksize: + for nTries in range( self.nTries ): print "\tWaiting for the next block, try %03d ..." % (nTries+1) - time.sleep( self.__delay ) - self.__fp.seek( fpointer ) - fpointer = self.__fp.tell() - junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read ) - if junk.size == self.__blocksize: + time.sleep( self.delay ) + self.fp.seek( fpointer ) + fpointer = self.fp.tell() + junk = numpy.fromfile( self.fp, self.dataType, self.pts2read ) + if junk.size == self.blocksize: blockOk_flag = True break @@ -736,8 +237,8 @@ class VoltageReader(JRODataReader): #data = junk['real'] + junk['imag']*1j self.datablock = junk['real'] + junk['imag']*1j - self.__datablockIndex = 0 - self.__flagIsNewFile = 0 + self.datablockIndex = 0 + self.flagIsNewFile = 0 self.idProfile = 0 self.flagIsNewBlock = 1 @@ -746,339 +247,6 @@ class VoltageReader(JRODataReader): return 1 - - def __hasNotDataInBuffer(self): - if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock: - return 1 - return 0 - - - def __searchFilesOnLine(self, path, startDateTime=None, ext = ".r"): - """ - 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 - startDateTime : punto especifico en el tiempo del cual se requiere la data - ext : extension de los files - - Return: - year : el anho - doy : el numero de dia del anho - set : el set del archivo - filename : el ultimo file de una determinada carpeta - directory : eL directorio donde esta el file encontrado - """ - print "Searching files ..." - - dirList = [] - directory = None - - if startDateTime == None: - for thisPath in os.listdir(path): - if os.path.isdir( os.path.join(path,thisPath) ): - dirList.append( thisPath ) - - dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted - if len(dirList) > 0 : - directory = dirList[-1] #me quedo con el ultimo directorio de una carpeta - else: - year = startDateTime.timetuple().tm_year - doy = startDateTime.timetuple().tm_yday - - doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas - if os.path.isdir( os.path.join(path,doyPath) ): - directory = doyPath - - doyPath = doyPath.lower() #caso del nombre en minusculas - if os.path.isdir( os.path.join(path,doyPath) ): - directory = doyPath - - if directory == None: - return 0, 0, 0, None, None - - filename = getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext ) - - if filename == None: - return 0, 0, 0, None, None - - year = int( directory[-7:-3] ) - doy = int( directory[-3:] ) - ln = len( ext ) - set = int( filename[-ln-3:-ln] ) - - return year, doy, set, filename, directory - - - def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"): - """ - Realiza una busqueda de los archivos que coincidan con los parametros - especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda - correcta la estructura de directorios debe ser la siguiente: - - ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext - - [yyyy]: anio - [ddd] : dia del anio - [sss] : set del archivo - - Inputs: - path : Directorio de datos donde se realizara la busqueda. Todos los - ficheros que concidan con el criterio de busqueda seran - almacenados en una lista y luego retornados. - startDateTime : Fecha inicial. Rechaza todos los archivos donde - file end time < startDateTime (obejto datetime.datetime) - - endDateTime : Fecha final. Rechaza todos los archivos donde - file start time > endDateTime (obejto datetime.datetime) - - set : Set del primer archivo a leer. Por defecto None - - expLabel : Nombre del subdirectorio de datos. Por defecto "" - - ext : Extension de los archivos a leer. Por defecto .r - - Return: - - (pathList, filenameList) - - pathList : Lista de directorios donde se encontraron archivos dentro - de los parametros especificados - filenameList : Lista de archivos (ruta completa) que coincidieron con los - parametros especificados. - - Variables afectadas: - - self.filenameList: Lista de archivos (ruta completa) que la clase utiliza - como fuente para leer los bloque de datos, si se termina - de leer todos los bloques de datos de un determinado - archivo se pasa al siguiente archivo de la lista. - - Excepciones: - - """ - print "Searching files ..." - - dirList = [] - for thisPath in os.listdir(path): - if os.path.isdir(os.path.join(path,thisPath)): - dirList.append(thisPath) - - pathList = [] - - thisDateTime = startDateTime - - while(thisDateTime <= endDateTime): - year = thisDateTime.timetuple().tm_year - doy = thisDateTime.timetuple().tm_yday - - match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy)) - if len(match) == 0: - thisDateTime += datetime.timedelta(1) - continue - - pathList.append(os.path.join(path,match[0],expLabel)) - thisDateTime += datetime.timedelta(1) - - startUtSeconds = time.mktime(startDateTime.timetuple()) - endUtSeconds = time.mktime(endDateTime.timetuple()) - - filenameList = [] - for thisPath in pathList: - fileList = glob.glob1(thisPath, "*%s" %ext) - fileList.sort() - for file in fileList: - filename = os.path.join(thisPath,file) - if isThisFileinRange(filename, startUtSeconds, endUtSeconds): - filenameList.append(filename) - - self.filenameList = filenameList - - return pathList, filenameList - - - def __initFilesOnline( self, path, dirfilename, filename ): - """ - Verifica que el primer file tenga una data valida, para ello leo el 1er bloque - del file, si no es un file valido espera una cierta cantidad de tiempo a que - lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo - devuelve 0 caso contrario devuelve 1 - - Affected: - m_BasicHeader - - Return: - 0 : file no valido para ser leido - 1 : file valido para ser leido - """ - m_BasicHeader = BasicHeader() - - file = os.path.join( path, dirfilename, filename ) - - for nTries in range( self.__nTries+1 ): - try: - fp = open( file,'rb' ) #lectura binaria - except: - raise IOError, "The file %s can't be opened" % (file) - - try: - m_BasicHeader.read(fp) - except: - print "The file %s is empty" % filename - - fp.close() - fp = None - - if m_BasicHeader.size > 24: - break - - if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar - break - - print '\twaiting for new block: try %02d' % ( nTries ) - time.sleep( self.__delay ) - - if m_BasicHeader.size <= 24: - return 0 - - return 1 - - - def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0): - """ - setup configura los parametros de lectura de la clase VoltageReader. - - Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos - que coincidan con los parametros especificados; esta lista de archivos son almacenados en - self.filenameList. - - Input: - path : Directorios donde se ubican los datos a leer. Dentro de este - directorio deberia de estar subdirectorios de la forma: - - path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext] - - startDateTime : Fecha inicial. Rechaza todos los archivos donde - file end time < startDatetime (obejto datetime.datetime) - - endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde - file end time < startDatetime (obejto datetime.datetime) - - set : Set del primer archivo a leer. Por defecto None - - expLabel : Nombre del subdirectorio de datos. Por defecto "" - - ext : Extension de los archivos a leer. Por defecto .r - - online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas - - Return: - 0 : Si no encuentra files que cumplan con las condiciones dadas - 1 : Si encuentra files que cumplan con las condiciones dadas - - Affected: - self.startUTCSeconds - self.endUTCSeconds - self.startYear - self.endYear - self.startDoy - self.endDoy - self.__pathList - self.filenameList - self.online - """ - if online: - fileOK_flag = False - subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday ) - file = os.path.join( path, subfolder ) - - for nTries in range( self.__nTries+1 ): #espera por el 1er file - year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext ) - - if filename != None: - if isFileOK( os.path.join( path,dirfilename,filename ) ): - fileOK_flag = True - break - - if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar - break - - print "Searching first file in \"%s\", try %03d ..." % ( file, nTries+1 ) - time.sleep( self.__delay ) - - if not( fileOK_flag ): #filename == None: - print "No files on line or invalid first file" - return 0 - - if self.__initFilesOnline( path, dirfilename, filename ) == 0: - print "The file %s hasn't enough data" % filename - return 0 - - self.__year = year - self.__doy = doy - self.__set = set - 1 - self.__path = path - - else: - pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext ) - self.__idFile = -1 - self.__pathList = pathList - self.filenameList = filenameList - - self.online = online - self.__ext = ext - - if not( self.__setNextFile() ): - if (startDateTime != None) and (endDateTime != None): - print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime()) - elif startDateTime != None: - print "No files in : %s" % startDateTime.ctime() - else: - print "No files" - return 0 - - if startDateTime != None: - self.startUTCSeconds = time.mktime(startDateTime.timetuple()) - self.startYear = startDateTime.timetuple().tm_year - self.startDoy = startDateTime.timetuple().tm_yday - - if endDateTime != None: - self.endUTCSeconds = time.mktime(endDateTime.timetuple()) - self.endYear = endDateTime.timetuple().tm_year - self.endDoy = endDateTime.timetuple().tm_yday - #call fillHeaderValues() - to Data Object - - self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy() - self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy() - self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy() - self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy() - self.m_Voltage.dataType = self.__dataType - - return 1 - - - def readNextBlock(self): - """ - Establece un nuevo bloque de datos a leer y los lee, si es que no existiese - mas bloques disponibles en el archivo actual salta al siguiente. - - Affected: - self.__lastUTTime - - Return: None - """ - if not(self.__setNewBlock()): - return 0 - - if not( self.__readBlock() ): - return 0 - - self.__lastUTTime = self.m_BasicHeader.utc - - return 1 - - def getData(self): """ getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage" @@ -1092,13 +260,13 @@ class VoltageReader(JRODataReader): buffer. Si no hay mas archivos a leer retorna None. Variables afectadas: - self.m_Voltage - self.__datablockIndex + self.m_DataObj + self.datablockIndex self.idProfile Affected: - self.m_Voltage - self.__datablockIndex + self.m_DataObj + self.datablockIndex self.flagResetProcessing self.flagIsNewBlock self.idProfile @@ -1108,18 +276,18 @@ class VoltageReader(JRODataReader): self.flagResetProcessing = 0 self.flagIsNewBlock = 0 - if self.__hasNotDataInBuffer(): + if self.hasNotDataInBuffer(): if not( self.readNextBlock() ): - self.__setNextFile() + self.setNextFile() return 0 - self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy() - self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy() - self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy() - self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy() - self.m_Voltage.heights = self.__heights - self.m_Voltage.dataType = self.__dataType + self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy() + self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy() + self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy() + self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy() + self.m_DataObj.heights = self.heights + self.m_DataObj.dataType = self.dataType if self.noMoreFiles == 1: print 'Process finished' @@ -1128,25 +296,25 @@ class VoltageReader(JRODataReader): #data es un numpy array de 3 dmensiones (perfiles, alturas y canales) if self.datablock == None: - self.m_Voltage.flagNoData = True + self.m_DataObj.flagNoData = True return 0 - time = self.m_BasicHeader.utc + self.__datablockIndex * self.__ippSeconds - self.__utc = time - #self.m_Voltage.m_BasicHeader.utc = time + time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds + self.utc = time + #self.m_DataObj.m_BasicHeader.utc = time - self.m_Voltage.flagNoData = False - self.m_Voltage.flagResetProcessing = self.flagResetProcessing + self.m_DataObj.flagNoData = False + self.m_DataObj.flagResetProcessing = self.flagResetProcessing - self.m_Voltage.data = self.datablock[self.__datablockIndex,:,:] - self.m_Voltage.idProfile = self.idProfile + self.m_DataObj.data = self.datablock[self.datablockIndex,:,:] + self.m_DataObj.idProfile = self.idProfile - self.__datablockIndex += 1 + self.datablockIndex += 1 self.idProfile += 1 #call setData - to Data Object - return 1 #self.m_Voltage.data + return 1 #self.m_DataObj.data class VoltageWriter( JRODataWriter ): """ @@ -1160,7 +328,7 @@ class VoltageWriter( JRODataWriter ): Inicializador de la clase VoltageWriter para la escritura de datos de espectros. Affected: - self.m_Voltage + self.m_DataObj self.m_BasicHeader self.m_SystemHeader self.m_RadarControllerHeader @@ -1171,29 +339,31 @@ class VoltageWriter( JRODataWriter ): if m_Voltage == None: m_Voltage = Voltage() - self.m_Voltage = m_Voltage - - self.__path = None + self.m_DataObj = m_Voltage - self.__fp = None + self.fp = None - self.__format = None + self.format = None - self.__blocksCounter = 0 + self.blocksCounter = 0 - self.__setFile = None + self.setFile = None - self.__flagIsNewFile = 1 + self.flagIsNewFile = 1 self.datablock = None - self.__datablockIndex = 0 + self.datablockIndex = 0 + + self.dataType = None + + self.ext = ".r" - self.__dataType = None + self.path = None - self.__ext = None + self.optchar = "D" - self.__shapeBuffer = None + self.shapeBuffer = None self.nWriteBlocks = 0 @@ -1211,245 +381,55 @@ class VoltageWriter( JRODataWriter ): self.m_ProcessingHeader = ProcessingHeader() - - 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 - """ - self.__writeBasicHeader() - self.__wrSystemHeader() - self.__wrRadarControllerHeader() - self.__wrProcessingHeader() - self.__dataType = self.m_Voltage.dataType - - - def __writeBasicHeader(self,fp=None): - """ - Escribe solo el Basic header en el file creado - - Return: - None - """ - if fp == None: - fp = self.__fp - - self.m_BasicHeader.write(fp) - - - def __wrSystemHeader(self,fp=None): - """ - Escribe solo el System header en el file creado - - Return: - None - """ - if fp == None: - fp = self.__fp - - self.m_SystemHeader.write(fp) - - - def __wrRadarControllerHeader(self,fp=None): - """ - Escribe solo el RadarController header en el file creado - - Return: - None - """ - if fp == None: - fp = self.__fp - - self.m_RadarControllerHeader.write(fp) + def hasAllDataInBuffer(self): + if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock: + return 1 + return 0 + def setBlockDimension(self): - def __wrProcessingHeader(self,fp=None): - """ - Escribe solo el Processing header en el file creado - - Return: - None - """ - if fp == None: - fp = self.__fp + self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock, + self.m_ProcessingHeader.numHeights, + self.m_SystemHeader.numChannels ) - self.m_ProcessingHeader.write(fp) - - - def __setNextFile(self): - """ - Determina el siguiente file que sera escrito - - Affected: - self.filename - self.__subfolder - self.__fp - self.__setFile - self.__flagIsNewFile - - Return: - 0 : Si el archivo no puede ser escrito - 1 : Si el archivo esta listo para ser escrito - """ - #setFile = self.__setFile - ext = self.__ext - path = self.__path + self.datablock = numpy.zeros(self.shapeBuffer, numpy.dtype('complex')) - #setFile += 1 - - if self.__fp != None: - self.__fp.close() - - """ - timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage - file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext) - subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday) - tmp = os.path.join(path,subfolder) - if not(os.path.exists(tmp)): - os.mkdir(tmp) - """ - ################################## - """ - if self.m_BasicHeader.size <= 24: - self.__fp.close() - self.__fp = None - return 0 #no existe la suficiente data para ser escrita - """ - - timeTuple = time.localtime( self.m_Voltage.m_BasicHeader.utc ) # utc from m_Voltage - subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday) - - tmp = os.path.join( path, subfolder ) - if not( os.path.exists(tmp) ): - os.mkdir(tmp) - self.__setFile = -1 #inicializo mi contador de seteo - else: - filesList = os.listdir( tmp ) - 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) - # D 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 = 'D%4.4d%3.3d%3.3d%s' % ( timeTuple.tm_year, timeTuple.tm_yday, setFile, ext ) - ################################## - - filename = os.path.join( path, subfolder, file ) - - fp = open( filename,'wb' ) - - self.__blocksCounter = 0 - - #guardando atributos - self.filename = filename - self.__subfolder = subfolder - self.__fp = fp - self.__setFile = setFile - self.__flagIsNewFile = 1 - - print 'Writing the file: %s'%self.filename - - self.__writeFirstHeader() - - return 1 - - - def __setNewBlock(self): - """ - Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header - - Return: - 0 : si no pudo escribir nada - 1 : Si escribio el Basic el First Header - """ - if self.__fp == None: - self.__setNextFile() - - if self.__flagIsNewFile: - return 1 - - if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile: - self.__writeBasicHeader() - return 1 - - if not( self.__setNextFile() ): - return 0 - - return 1 - - - def __writeBlock(self): + def writeBlock(self): """ Escribe el buffer en el file designado Affected: - self.__datablockIndex - self.__flagIsNewFile + self.datablockIndex + self.flagIsNewFile self.flagIsNewBlock self.nWriteBlocks - self.__blocksCounter + self.blocksCounter Return: None """ - data = numpy.zeros( self.__shapeBuffer, self.__dataType ) + data = numpy.zeros( self.shapeBuffer, self.dataType ) data['real'] = self.datablock.real data['imag'] = self.datablock.imag data = data.reshape( (-1) ) - data.tofile( self.__fp ) + data.tofile( self.fp ) self.datablock.fill(0) - self.__datablockIndex = 0 - self.__flagIsNewFile = 0 + self.datablockIndex = 0 + self.flagIsNewFile = 0 self.flagIsNewBlock = 1 self.nWriteBlocks += 1 - self.__blocksCounter += 1 - - - def writeNextBlock(self): - """ - Selecciona el bloque siguiente de datos y los escribe en un file - - Return: - 0 : Si no hizo pudo escribir el bloque de datos - 1 : Si no pudo escribir el bloque de datos - """ - if not(self.__setNewBlock()): - return 0 + self.blocksCounter += 1 - self.__writeBlock() - return 1 - - - def __hasAllDataInBuffer(self): - if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock: - return 1 - return 0 - - def putData(self): """ Setea un bloque de datos y luego los escribe en un file Affected: self.flagIsNewBlock - self.__datablockIndex + self.datablockIndex Return: 0 : Si no hay data o no hay mas files que puedan escribirse @@ -1457,21 +437,21 @@ class VoltageWriter( JRODataWriter ): """ self.flagIsNewBlock = 0 - if self.m_Voltage.flagNoData: + if self.m_DataObj.flagNoData: return 0 - if self.m_Voltage.flagResetProcessing: + if self.m_DataObj.flagResetProcessing: self.datablock.fill(0) - self.__datablockIndex = 0 - self.__setNextFile() + self.datablockIndex = 0 + self.setNextFile() - self.datablock[self.__datablockIndex,:,:] = self.m_Voltage.data + self.datablock[self.datablockIndex,:,:] = self.m_DataObj.data - self.__datablockIndex += 1 + self.datablockIndex += 1 - if self.__hasAllDataInBuffer(): - self.__getHeader() + if self.hasAllDataInBuffer(): + self.getHeader() self.writeNextBlock() if self.noMoreFiles: @@ -1479,153 +459,6 @@ class VoltageWriter( JRODataWriter ): return 0 return 1 - - - def __getHeader(self): - """ - Obtiene una copia del First Header - - Affected: - self.m_BasicHeader - self.m_SystemHeader - self.m_RadarControllerHeader - self.m_ProcessingHeader - self.__dataType - - Return: - None - """ - self.m_BasicHeader = self.m_Voltage.m_BasicHeader.copy() - self.m_SystemHeader = self.m_Voltage.m_SystemHeader.copy() - self.m_RadarControllerHeader = self.m_Voltage.m_RadarControllerHeader.copy() - self.m_ProcessingHeader = self.m_Voltage.m_ProcessingHeader.copy() - self.__dataType = self.m_Voltage.dataType - - - def __setHeaderByFile(self): - - format = self.__format - header = ['Basic','System','RadarController','Processing'] - - fmtFromFile = None - headerFromFile = None - - - fileTable = self.__configHeaderFile - - if os.access(fileTable, os.R_OK): - import re, string - - f = open(fileTable,'r') - lines = f.read() - f.close() - - #Delete comments into expConfig - while 1: - - startComment = string.find(lines.lower(),'#') - if startComment == -1: - break - endComment = string.find(lines.lower(),'\n',startComment) - lines = string.replace(lines,lines[startComment:endComment+1],'', 1) - - while expFromFile == None: - - currFmt = string.find(lines.lower(),'format="%s"' %(expName)) - nextFmt = string.find(lines.lower(),'format',currFmt+10) - - if currFmt == -1: - break - if nextFmt == -1: - nextFmt = len(lines)-1 - - fmtTable = lines[currFmt:nextFmt] - lines = lines[nextFmt:] - - fmtRead = self.__getValueFromArg(fmtTable,'format') - if fmtRead != format: - continue - fmtFromFile = fmtRead - - lines2 = fmtTable - - while headerFromFile == None: - - currHeader = string.find(lines2.lower(),'header="%s"' %(header)) - nextHeader = string.find(lines2.lower(),'header',currHeader+10) - - if currHeader == -1: - break - if nextHeader == -1: - nextHeader = len(lines2)-1 - - headerTable = lines2[currHeader:nextHeader] - lines2 = lines2[nextHeader:] - - headerRead = self.__getValueFromArg(headerTable,'site') - if not(headerRead in header): - continue - headerFromFile = headerRead - - if headerRead == 'Basic': - self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False) - self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False) - self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False) - self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False) - self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False) - self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False) - self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False) - self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False) - - else: - print "file access denied:%s"%fileTable - sys.exit(0) - - - def setup(self,path,set=0,format='rawdata'): - """ - 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: - 0 : Si no realizo un buen seteo - 1 : Si realizo un buen seteo - """ - if format == 'hdf5': - ext = '.hdf5' - format = 'hdf5' - print 'call hdf5 library' - return 0 - - if format == 'rawdata': - ext = '.r' - format = 'Jicamarca' - - #call to config_headers - #self.__setHeaderByFile() - - self.__path = path - self.__setFile = set - 1 - self.__ext = ext - self.__format = format - - self.__getHeader() - self.__shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock, - self.m_ProcessingHeader.numHeights, - self.m_SystemHeader.numChannels ) - - self.datablock = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex')) - - if not( self.__setNextFile() ): - return 0 - - return 1 - - \ No newline at end of file