diff --git a/schainpy/IO/SpectraIO.py b/schainpy/IO/SpectraIO.py index 0e9b4c8..fe24b6c 100644 --- a/schainpy/IO/SpectraIO.py +++ b/schainpy/IO/SpectraIO.py @@ -1,353 +1,813 @@ -''' -Created on 23/01/2012 - -@author $Author$ -@version $Id$ -''' - -from Header import * -from DataIO import DataReader -from DataIO import DataWriter - - -class SpectraReader(DataReader): - """ - Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura - de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones: - nFFTs*alturas*canales) son almacenados en la variable "buffer". - - Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader, - RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la - cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de - datos desde el "buffer" cada vez que se ejecute el metodo "getData". - - Example: - - dpath = "/home/myuser/data" - - startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0) - - endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0) - - readerObj = SpectraReader() - - readerObj.setup(dpath, startTime, endTime) - - while(True): - - readerObj.getData() - - print readerObj.m_Spectra.data - - if readerObj.noMoreFiles: - break - - """ - - #speed of light - __c = 3E8 - - def __init__(self, m_Spectra = None): - """ - Inicializador de la clase SpectraReader para la lectura de datos de espectros. - - Input: - m_Spectra : Objeto de la clase Voltage. Este objeto sera utilizado para - almacenar un perfil de datos cada vez que se haga un requerimiento - (getData). El perfil sera obtenido a partir del buffer de datos, - si el buffer esta vacio se hara un nuevo proceso de lectura de un - bloque de datos. - Si este parametro no es pasado se creara uno internamente. - - Variables afectadas: - self.m_Spectra - self.m_BasicHeader - self.m_SystemHeader - self.m_RadarControllerHeader - self.m_ProcessingHeader - - - Return: - Void - - """ - if m_Spectra == None: - m_Spectra = Voltage() - - if not(isinstance(m_Spectra, Voltage)): - raise ValueError, "in VoltageReader, m_Spectra must be an Voltage class object" - - self.m_Spectra = m_Spectra - - self.m_BasicHeader = BasicHeader() - - self.m_SystemHeader = SystemHeader() - - self.m_RadarControllerHeader = RadarControllerHeader() - - self.m_ProcessingHeader = ProcessingHeader() - - self.__fp = None - - self.__idFile = 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.__buffer = 0 - - self.__buffer_id = 9999 - - 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) - - def __rdBasicHeader(self, fp=None): - - if fp == None: - fp = self.__fp - - self.m_BasicHeader.read(fp) - - def __readFirstHeader(self): - - self.__rdBasicHeader() - self.__rdSystemHeader() - self.__rdRadarControllerHeader() - self.__rdProcessingHeader() - self.firstHeaderSize = self.m_BasicHeader.size - - def __setNextFileOnline(self): - return 1 - - def __setNextFileOffline(self): - - return 1 - - def __setNextFile(self): - - - - return 1 - - def __setNewBlock(self): - - - return 1 - - def __readBlock(self): - """ - __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo - (self.__fp) y actualiza todos los parametros relacionados al bloque de datos - (metadata + data). La data leida es almacenada en el buffer y el contador del buffer - es seteado a 0 - - - Inputs: - None - - Return: - None - - Variables afectadas: - - self.__buffer_id - - self.__buffer - - self.__flagIsNewFile - - self.idProfile - - self.flagIsNewBlock - - self.nReadBlocks - - """ - - - def __hasNotDataInBuffer(self): - - - return 0 - - def __searchFiles(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata"): - """ - __searchFiles 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: - - """ - - - - def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".pdata", 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 : - - Return: - - Affected: - - Excepciones: - - Example: - - """ - - - def readNextBlock(self): - """ - readNextBlock 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. - - """ - - - return 1 - - def getData(self): - """ - getData copia el buffer de lectura a la clase "Spectra", - con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de - lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock" - - - Inputs: - None - - Return: - data : retorna un bloque de datos (nFFTs * alturas * canales) copiados desde el - buffer. Si no hay mas archivos a leer retorna None. - - Variables afectadas: - self.m_Spectra - self.__buffer_id - self.idProfile - - Excepciones: - - """ - - - return data - -class SpectraWriter(DataWriter): - def __init__(self): - pass - +''' +File: SpectraIO.py +Created on 20/02/2012 + +@author $Author$ +@version $Id$ +''' + +import os, sys +import numpy +import glob +import fnmatch +import time, datetime + +path = os.path.split(os.getcwd())[0] +sys.path.append(path) + +from HeaderIO import * +from DataIO import DataReader +from DataIO import DataWriter + +from Model.Spectra import Spectra + +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 SpectraReader(DataReader): + """ + Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura + de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones: + perfiless*alturas*canales) son almacenados en la variable "buffer". + + Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader, + RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la + cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de + datos desde el "buffer" cada vez que se ejecute el metodo "getData". + + Example: + + dpath = "/home/myuser/data" + + startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0) + + endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0) + + readerObj = SpectraReader() + + readerObj.setup(dpath, startTime, endTime) + + while(True): + + readerObj.getData() + + print readerObj.m_Spectra.data + + if readerObj.noMoreFiles: + break + + """ + + #speed of light + __c = 3E8 + + def __init__( self, m_Spectra = None ): + """ + Inicializador de la clase SpectraReader para la lectura de datos de espectros. + + Input: + m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para + almacenar un perfil de datos cada vez que se haga un requerimiento + (getData). El perfil sera obtenido a partir del buffer de datos, + si el buffer esta vacio se hara un nuevo proceso de lectura de un + bloque de datos. + Si este parametro no es pasado se creara uno internamente. + + Variables afectadas: + self.m_Spectra + self.m_BasicHeader + self.m_SystemHeader + self.m_RadarControllerHeader + self.m_ProcessingHeader + + + Return: + Void + + """ + if m_Spectra == None: + m_Spectra = Spectra() + + 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_BasicHeader = BasicHeader() + + self.m_SystemHeader = SystemHeader() + + self.m_RadarControllerHeader = RadarControllerHeader() + + self.m_ProcessingHeader = ProcessingHeader() + + self.__fp = None + + self.__idFile = 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.flagResetProcessing = 0 + + self.flagIsNewBlock = 0 + + self.noMoreFiles = 0 + + self.nReadBlocks = 0 + + self.online = 0 + + self.firstHeaderSize = 0 + + self.basicHeaderSize = 24 + + self.filename = None + + self.fileSize = None + + self.__buffer_spc = None + self.__buffer_cspc = None + self.__buffer_dc = None + + self.__buffer_id = 0 + + self.__ippSeconds = 0 + + self.nSelfChannels = 0 + + self.nCrossPairs = 0 + + self.nChannels = 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) + + def __rdBasicHeader( self, fp=None ): + if fp == None: + fp = self.__fp + + self.m_BasicHeader.read(fp) + + def __readFirstHeader( self ): + 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','= neededSize ): + self.__rdBasicHeader() + return 1 + + #Setting new file + if not( self.__setNextFile() ): + return 0 + + deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this + + self.flagResetProcessing = 0 + + if deltaTime > self.__maxTimeStep: + self.flagResetProcessing = 1 + self.ns = 0 + + return 1 + + + + def __readBlock(self): + """ + __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo + (self.__fp) y actualiza todos los parametros relacionados al bloque de datos + (metadata + data). La data leida es almacenada en el buffer y el contador del buffer + es seteado a 0 + + Inputs: + None + + Return: + None + + Variables afectadas: + + self.__buffer_id + + self.__buffer_sspc + + self.__flagIsNewFile + + self.flagIsNewBlock + + self.nReadBlocks + + """ + Npair_SelfSpectra = 0 + Npair_CrossSpectra = 0 + + for i in range( 0,self.m_ProcessingHeader.totalSpectra*2,2 ): + if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]: + Npair_SelfSpectra = Npair_SelfSpectra + 1 + else: + Npair_CrossSpectra = Npair_CrossSpectra + 1 + +# self.__buffer_sspc = numpy.concatenate( (data_sspc,data_cspc,data_dcc), axis=0 ) + + self.__buffer_id = 0 + self.__flagIsNewFile = 0 + self.flagIsNewBlock = 1 + + pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights + + spc = numpy.fromfile(self.__fp, self.__dataType[0], int(pts2read*Npair_SelfSpectra)) + cspc = numpy.fromfile(self.__fp, self.__dataType, int(pts2read*Npair_CrossSpectra)) + dc = numpy.fromfile(self.__fp, self.__dataType, int(pts2read*self.m_SystemHeader.numChannels) ) + + spc = spc.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, Npair_SelfSpectra)) + cspc = cspc.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, Npair_CrossSpectra)) + dc = dc.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels)) + + data_spc = spc + data_cspc = cspc['real'] + cspc['imag']*1j + data_dc = dc['real'] + dc['imag']*1j + + self.__buffer_spc = data_spc + self.__buffer_cspc = data_cspc + self.__buffer_dc = data_dc + + self.__flagIsNewFile = 0 + + self.flagIsNewBlock = 1 + + self.nReadBlocks += 1 + + + def __hasNotDataInBuffer(self): + return 1 + + def __searchFiles(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata"): + """ + __searchFiles 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. + + 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 setup( self, path, startDateTime, 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 .r + + online : + + Return: + + Affected: + + Excepciones: + + Example: + + """ + if online == 0: + pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext) + + self.__idFile = -1 + + if not(self.__setNextFile()): + print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime()) + return 0 + + self.startUTCSeconds = time.mktime(startDateTime.timetuple()) + self.endUTCSeconds = time.mktime(endDateTime.timetuple()) + + self.startYear = startDateTime.timetuple().tm_year + self.endYear = endDateTime.timetuple().tm_year + + self.startDoy = startDateTime.timetuple().tm_yday + self.endDoy = endDateTime.timetuple().tm_yday + #call fillHeaderValues() - to Data Object + + self.__pathList = pathList + self.filenameList = filenameList + self.online = online + + return 1 + + def readNextBlock(self): + """ + readNextBlock 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. + + """ + + if not( self.__setNewBlock() ): + return 0 + + self.__readBlock() + + self.__lastUTTime = self.m_BasicHeader.utc + + return 1 + + + def getData(self): + """ + getData copia el buffer de lectura a la clase "Spectra", + con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de + lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock" + + Inputs: + None + + Return: + data : retorna un bloque de datos (nFFTs * alturas * canales) copiados desde el + buffer. Si no hay mas archivos a leer retorna None. + + Variables afectadas: + self.m_Spectra + self.__buffer_id + + Excepciones: + + """ + + self.flagResetProcessing = 0 + self.flagIsNewBlock = 0 + + if self.__hasNotDataInBuffer(): + self.readNextBlock() + + 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 + + if self.noMoreFiles == 1: + print 'Process finished' + return 0 + + #data es un numpy array de 3 dmensiones (perfiles, alturas y canales) + #print type(self.__buffer_sspc) + + time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds + + self.m_Spectra.m_BasicHeader.utc = time + self.m_Spectra.data_spc = self.__buffer_spc + self.m_Spectra.data_cspc = self.__buffer_cspc + self.m_Spectra.data_dc = self.__buffer_dc + + #call setData - to Data Object + + return 1 + + +class SpectraWriter(DataWriter): + + def __init__(self): + if m_Spectra == None: + m_Spectra = Spectra() + + self.m_Spectra = m_Spectra + + self.__fp = None + + self.__blocksCounter = 0 + + self.__setFile = None + + self.__flagIsNewFile = 0 + + self.__buffer_sspc = 0 + + self.__buffer_id = 0 + + self.__dataType = None + + self.__ext = None + + self.nWriteBlocks = 0 + + self.flagIsNewBlock = 0 + + self.noMoreFiles = 0 + + self.filename = None + + self.m_BasicHeader= BasicHeader() + + self.m_SystemHeader = SystemHeader() + + self.m_RadarControllerHeader = RadarControllerHeader() + + self.m_ProcessingHeader = ProcessingHeader() + + def __setNextFile(self): + setFile = self.__setFile + ext = self.__ext + path = self.__path + + setFile += 1 + + if not(self.__blocksCounter >= self.m_ProcessingHeader.dataBlocksPerFile): + self.__fp.close() + return 0 + + timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra + file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_doy,setFile,ext) + subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_doy) + tmp = os.path.join(path,subfolder) + if not(os.path.exists(tmp)): + os.mkdir(tmp) + + filename = os.path.join(path,subfolder,file) + fp = open(filename,'wb') + + #guardando atributos + self.filename = filename + self.__subfolder = subfolder + self.__fp = fp + self.__setFile = setFile + self.__flagIsNewFile = 1 + + print 'Writing the file: %s'%self.filename + + return 1 + + + + def __setNewBlock(self): + if self.__fp == None: + return 0 + + if self.__flagIsNewFile: + return 1 + + #Bloques completados? + if self.__blocksCounter < self.m_ProcessingHeader.profilesPerBlock: + self.__writeBasicHeader() + return 1 + + if not(self.__setNextFile()): + return 0 + + self.__writeFirstHeader() + + return 1 + + def __writeBlock(self): + + numpy.save(self.__fp,self.__buffer_sspc) + + self.__buffer_sspc = numpy.array([],self.__dataType) + + self.__buffer_id = 0 + + self.__flagIsNewFile = 0 + + self.flagIsNewBlock = 1 + + self.nWriteBlocks += 1 + + self.__blocksCounter += 1 + + def writeNextBlock(self): + if not(self.__setNewBlock()): + return 0 + + self.__writeBlock() + + return 1 + + def __hasAllDataInBuffer(self): + if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock: + return 1 + + return 0 + + def putData(self): + self.flagIsNewBlock = 0 + + if self.m_Spectra.noData: + return None + + shape = self.m_Spectra.data.shape + data = numpy.zeros(shape,self.__dataType) + data['real'] = self.m_Spectra.data.real + data['imag'] = self.m_Spectra.data.imag + data = data.reshape((-1)) + + self.__buffer_sspc = numpy.hstack((self.__buffer_sspc,data)) + + self.__buffer_id += 1 + + if __hasAllDataInBuffer(): + self.writeNextBlock() + + + if self.noMoreFiles: + print 'Process finished' + return None + + return 1 + + + def setup(self,path,set=None,format=None): + + if set == None: + set = -1 + else: + set -= 1 + + if format == 'hdf5': + ext = '.hdf5' + print 'call hdf5 library' + return 0 + + if format == 'rawdata': + ext = '.r' + + #call to config_headers + + self.__setFile = set + + if not(self.__setNextFile()): + print "zzzzzzzzzzzz" + return 0 + + self.__writeFirstHeader() # dentro de esta funcion se debe setear e __dataType + + self.__buffer_sspc = numpy.array([],self.__dataType) + + + + def __writeBasicHeader(self): + pass + + def __writeFirstHeader(self): + pass diff --git a/schainpy/Model/Spectra.py b/schainpy/Model/Spectra.py index dac0d22..f0879c9 100644 --- a/schainpy/Model/Spectra.py +++ b/schainpy/Model/Spectra.py @@ -1,22 +1,67 @@ -''' -Created on Feb 7, 2012 - -@author $Author$ -@version $Id$ -''' - -class Spectra(Data): - ''' - classdocs - ''' - - - def __init__(self): - ''' - Constructor - ''' - pass - - def copy(self): - pass +''' +Created on Feb 7, 2012 + +@author $Author$ +@version $Id$ +''' +import os, sys + +path = os.path.split(os.getcwd())[0] +sys.path.append(path) + +from Model.Data import Data +from IO.HeaderIO import * + + +class Spectra(Data): + ''' + classdocs + ''' + + + def __init__(self): + ''' + Constructor + ''' + + self.m_RadarControllerHeader = RadarControllerHeader() + + self.m_ProcessingHeader = ProcessingHeader() + + self.m_SystemHeader = SystemHeader() + + self.m_BasicHeader = BasicHeader() + + #data es un numpy array de 3 dmensiones (perfiles, alturas y canales) + self.data_spc = None + + self.data_cspc = None + + self.data_dc = None + + self.heights = None + + self.noData = True + + self.nProfiles = None + + self.dataType = None + + def copy(self): + obj = Spectra() + obj.m_BasicHeader = self.m_BasicHeader.copy() + obj.m_SystemHeader = self.m_SystemHeader.copy() + obj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy() + obj.m_ProcessingHeader = self.m_ProcessingHeader.copy() + + obj.data_spc = self.data_spc + obj.data_cspc = self.data_cspc + obj.data_dc = self.data_dc + + obj.heights = self.heights + obj.noData = self.noData + + obj.nProfiles = self.nProfiles + + return obj \ No newline at end of file