jroIO_amisr.py
692 lines
| 24.0 KiB
| text/x-python
|
PythonLexer
Daniel Valdez
|
r491 | ''' | ||
| @author: Daniel Suarez | ||||
| ''' | ||||
| import os | ||||
| import sys | ||||
| import glob | ||||
| import fnmatch | ||||
| import datetime | ||||
|
Daniel Valdez
|
r497 | import time | ||
|
Daniel Valdez
|
r491 | import re | ||
| import h5py | ||||
| import numpy | ||||
Miguel Valdez
|
r568 | from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation | ||
| from schainpy.model.data.jroamisr import AMISR | ||||
|
Daniel Valdez
|
r491 | |||
|
Miguel Valdez
|
r587 | try: | ||
| from gevent import sleep | ||||
| except: | ||||
| from time import sleep | ||||
|
Daniel Valdez
|
r491 | class RadacHeader(): | ||
| def __init__(self, fp): | ||||
| header = 'Raw11/Data/RadacHeader' | ||||
| self.beamCodeByPulse = fp.get(header+'/BeamCode') | ||||
| self.beamCode = fp.get('Raw11/Data/Beamcodes') | ||||
| self.code = fp.get(header+'/Code') | ||||
| self.frameCount = fp.get(header+'/FrameCount') | ||||
| self.modeGroup = fp.get(header+'/ModeGroup') | ||||
| self.nsamplesPulse = fp.get(header+'/NSamplesPulse') | ||||
| self.pulseCount = fp.get(header+'/PulseCount') | ||||
| self.radacTime = fp.get(header+'/RadacTime') | ||||
| self.timeCount = fp.get(header+'/TimeCount') | ||||
| self.timeStatus = fp.get(header+'/TimeStatus') | ||||
| self.nrecords = self.pulseCount.shape[0] #nblocks | ||||
| self.npulses = self.pulseCount.shape[1] #nprofile | ||||
| self.nsamples = self.nsamplesPulse[0,0] #ngates | ||||
| self.nbeams = self.beamCode.shape[1] | ||||
|
Daniel Valdez
|
r497 | |||
|
Daniel Valdez
|
r491 | |||
| def getIndexRangeToPulse(self, idrecord=0): | ||||
|
Daniel Valdez
|
r497 | #indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0) | ||
| #startPulseCountId = indexToZero[0][0] | ||||
| #endPulseCountId = startPulseCountId - 1 | ||||
| #range1 = numpy.arange(startPulseCountId,self.npulses,1) | ||||
| #range2 = numpy.arange(0,startPulseCountId,1) | ||||
| #return range1, range2 | ||||
|
Daniel Valdez
|
r508 | zero = 0 | ||
| npulse = max(self.pulseCount[0,:]+1)-1 | ||||
| looking_index = numpy.where(self.pulseCount.value[idrecord,:]==npulse)[0] | ||||
| getLastIndex = looking_index[-1] | ||||
| index_data = numpy.arange(0,getLastIndex+1,1) | ||||
| index_buffer = numpy.arange(getLastIndex+1,self.npulses,1) | ||||
|
Daniel Valdez
|
r497 | return index_data, index_buffer | ||
|
Daniel Valdez
|
r491 | |||
| class AMISRReader(ProcessingUnit): | ||||
| path = None | ||||
| startDate = None | ||||
| endDate = None | ||||
| startTime = None | ||||
| endTime = None | ||||
| walk = None | ||||
| isConfig = False | ||||
| def __init__(self): | ||||
| self.set = None | ||||
| self.subset = None | ||||
| self.extension_file = '.h5' | ||||
| self.dtc_str = 'dtc' | ||||
| self.dtc_id = 0 | ||||
| self.status = True | ||||
| self.isConfig = False | ||||
| self.dirnameList = [] | ||||
| self.filenameList = [] | ||||
| self.fileIndex = None | ||||
| self.flagNoMoreFiles = False | ||||
| self.flagIsNewFile = 0 | ||||
| self.filename = '' | ||||
| self.amisrFilePointer = None | ||||
| self.radacHeaderObj = None | ||||
| self.dataOut = self.__createObjByDefault() | ||||
| self.datablock = None | ||||
| self.rest_datablock = None | ||||
| self.range = None | ||||
| self.idrecord_count = 0 | ||||
| self.profileIndex = 0 | ||||
|
Daniel Valdez
|
r497 | self.index_amisr_sample = None | ||
| self.index_amisr_buffer = None | ||||
|
Daniel Valdez
|
r491 | self.beamCodeByFrame = None | ||
| self.radacTimeByFrame = None | ||||
| #atributos originales tal y como esta en el archivo de datos | ||||
| self.beamCodesFromFile = None | ||||
| self.radacTimeFromFile = None | ||||
| self.rangeFromFile = None | ||||
| self.dataByFrame = None | ||||
| self.dataset = None | ||||
| self.beamCodeDict = {} | ||||
| self.beamRangeDict = {} | ||||
| #experiment cgf file | ||||
| self.npulsesint_fromfile = None | ||||
| self.recordsperfile_fromfile = None | ||||
| self.nbeamcodes_fromfile = None | ||||
| self.ngates_fromfile = None | ||||
| self.ippSeconds_fromfile = None | ||||
| self.frequency_h5file = None | ||||
| self.__firstFile = True | ||||
| self.buffer_radactime = None | ||||
|
Daniel Valdez
|
r497 | self.index4_schain_datablock = None | ||
| self.index4_buffer = None | ||||
| self.schain_datablock = None | ||||
| self.buffer = None | ||||
| self.linear_pulseCount = None | ||||
| self.npulseByFrame = None | ||||
| self.profileIndex_offset = None | ||||
| self.timezone = 'ut' | ||||
|
Daniel Valdez
|
r508 | |||
| self.__waitForNewFile = 20 | ||||
| self.__filename_online = None | ||||
|
Daniel Valdez
|
r491 | def __createObjByDefault(self): | ||
| dataObj = AMISR() | ||||
| return dataObj | ||||
|
Daniel Valdez
|
r508 | def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''): | ||
|
Daniel Valdez
|
r491 | self.path = path | ||
| self.startDate = startDate | ||||
| self.endDate = endDate | ||||
| self.startTime = startTime | ||||
| self.endTime = endTime | ||||
| self.walk = walk | ||||
| def __checkPath(self): | ||||
| if os.path.exists(self.path): | ||||
| self.status = 1 | ||||
| else: | ||||
| self.status = 0 | ||||
| print 'Path:%s does not exists'%self.path | ||||
| return | ||||
| def __selDates(self, amisr_dirname_format): | ||||
| try: | ||||
| year = int(amisr_dirname_format[0:4]) | ||||
| month = int(amisr_dirname_format[4:6]) | ||||
| dom = int(amisr_dirname_format[6:8]) | ||||
| thisDate = datetime.date(year,month,dom) | ||||
| if (thisDate>=self.startDate and thisDate <= self.endDate): | ||||
| return amisr_dirname_format | ||||
| except: | ||||
| return None | ||||
|
Daniel Valdez
|
r508 | def __findDataForDates(self,online=False): | ||
|
Daniel Valdez
|
r491 | |||
| if not(self.status): | ||||
| return None | ||||
| pat = '\d+.\d+' | ||||
| dirnameList = [re.search(pat,x) for x in os.listdir(self.path)] | ||||
| dirnameList = filter(lambda x:x!=None,dirnameList) | ||||
| dirnameList = [x.string for x in dirnameList] | ||||
|
Daniel Valdez
|
r508 | if not(online): | ||
| dirnameList = [self.__selDates(x) for x in dirnameList] | ||||
| dirnameList = filter(lambda x:x!=None,dirnameList) | ||||
|
Daniel Valdez
|
r491 | if len(dirnameList)>0: | ||
| self.status = 1 | ||||
| self.dirnameList = dirnameList | ||||
| self.dirnameList.sort() | ||||
| else: | ||||
| self.status = 0 | ||||
| return None | ||||
| def __getTimeFromData(self): | ||||
|
Daniel Valdez
|
r499 | startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime) | ||
| endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime) | ||||
| print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader) | ||||
| print '........................................' | ||||
| filter_filenameList = [] | ||||
|
Daniel Valdez
|
r504 | self.filenameList.sort() | ||
|
Daniel Valdez
|
r500 | for i in range(len(self.filenameList)-1): | ||
| filename = self.filenameList[i] | ||||
|
Daniel Valdez
|
r499 | fp = h5py.File(filename,'r') | ||
| time_str = fp.get('Time/RadacTimeString') | ||||
| startDateTimeStr_File = time_str[0][0].split('.')[0] | ||||
| junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S') | ||||
| startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec) | ||||
| endDateTimeStr_File = time_str[-1][-1].split('.')[0] | ||||
| junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S') | ||||
| endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec) | ||||
| fp.close() | ||||
| if self.timezone == 'lt': | ||||
| startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300) | ||||
| endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300) | ||||
| if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader): | ||||
| #self.filenameList.remove(filename) | ||||
| filter_filenameList.append(filename) | ||||
| filter_filenameList.sort() | ||||
| self.filenameList = filter_filenameList | ||||
| return 1 | ||||
|
Daniel Valdez
|
r491 | |||
| def __filterByGlob1(self, dirName): | ||||
| filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file) | ||||
| filterDict = {} | ||||
| filterDict.setdefault(dirName) | ||||
| filterDict[dirName] = filter_files | ||||
| return filterDict | ||||
| def __getFilenameList(self, fileListInKeys, dirList): | ||||
| for value in fileListInKeys: | ||||
| dirName = value.keys()[0] | ||||
| for file in value[dirName]: | ||||
| filename = os.path.join(dirName, file) | ||||
| self.filenameList.append(filename) | ||||
|
Daniel Valdez
|
r508 | def __selectDataForTimes(self, online=False): | ||
|
Daniel Valdez
|
r491 | #aun no esta implementado el filtro for tiempo | ||
| if not(self.status): | ||||
| return None | ||||
| dirList = [os.path.join(self.path,x) for x in self.dirnameList] | ||||
| fileListInKeys = [self.__filterByGlob1(x) for x in dirList] | ||||
| self.__getFilenameList(fileListInKeys, dirList) | ||||
|
Daniel Valdez
|
r508 | if not(online): | ||
| #filtro por tiempo | ||||
| if not(self.all): | ||||
| self.__getTimeFromData() | ||||
|
Daniel Valdez
|
r499 | |||
|
Daniel Valdez
|
r508 | if len(self.filenameList)>0: | ||
| self.status = 1 | ||||
| self.filenameList.sort() | ||||
| else: | ||||
| self.status = 0 | ||||
| return None | ||||
|
Daniel Valdez
|
r510 | |||
|
Daniel Valdez
|
r491 | else: | ||
|
Daniel Valdez
|
r508 | #get the last file - 1 | ||
| self.filenameList = [self.filenameList[-2]] | ||||
|
Daniel Valdez
|
r510 | |||
| new_dirnameList = [] | ||||
| for dirname in self.dirnameList: | ||||
| junk = numpy.array([dirname in x for x in self.filenameList]) | ||||
| junk_sum = junk.sum() | ||||
| if junk_sum > 0: | ||||
| new_dirnameList.append(dirname) | ||||
| self.dirnameList = new_dirnameList | ||||
| return 1 | ||||
|
Daniel Valdez
|
r508 | |||
Juan C. Espinoza
|
r1052 | def searchFilesOnLine(self, | ||
|
Daniel Valdez
|
r508 | path, | ||
| walk=True): | ||||
| startDate = datetime.datetime.utcnow().date() | ||||
| endDate = datetime.datetime.utcnow().date() | ||||
| self.__setParameters(path=path, startDate=startDate, endDate=endDate, walk=walk) | ||||
| self.__checkPath() | ||||
| self.__findDataForDates(online=True) | ||||
| self.dirnameList = [self.dirnameList[-1]] | ||||
| self.__selectDataForTimes(online=True) | ||||
| return | ||||
|
Daniel Valdez
|
r491 | |||
|
Juan C. Espinoza
|
r1052 | def searchFilesOffLine(self, | ||
|
Daniel Valdez
|
r491 | path, | ||
| startDate, | ||||
| endDate, | ||||
| startTime=datetime.time(0,0,0), | ||||
| endTime=datetime.time(23,59,59), | ||||
| walk=True): | ||||
| self.__setParameters(path, startDate, endDate, startTime, endTime, walk) | ||||
| self.__checkPath() | ||||
| self.__findDataForDates() | ||||
| self.__selectDataForTimes() | ||||
| for i in range(len(self.filenameList)): | ||||
| print "%s" %(self.filenameList[i]) | ||||
| return | ||||
| def __setNextFileOffline(self): | ||||
| idFile = self.fileIndex | ||||
| while (True): | ||||
| idFile += 1 | ||||
| if not(idFile < len(self.filenameList)): | ||||
| self.flagNoMoreFiles = 1 | ||||
| print "No more Files" | ||||
| return 0 | ||||
| filename = self.filenameList[idFile] | ||||
| amisrFilePointer = h5py.File(filename,'r') | ||||
| break | ||||
| self.flagIsNewFile = 1 | ||||
| self.fileIndex = idFile | ||||
| self.filename = filename | ||||
| self.amisrFilePointer = amisrFilePointer | ||||
| print "Setting the file: %s"%self.filename | ||||
| return 1 | ||||
|
Daniel Valdez
|
r508 | |||
| def __setNextFileOnline(self): | ||||
| filename = self.filenameList[0] | ||||
| if self.__filename_online != None: | ||||
| self.__selectDataForTimes(online=True) | ||||
| filename = self.filenameList[0] | ||||
| while self.__filename_online == filename: | ||||
| print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile) | ||||
|
Miguel Valdez
|
r587 | sleep(self.__waitForNewFile) | ||
|
Daniel Valdez
|
r508 | self.__selectDataForTimes(online=True) | ||
| filename = self.filenameList[0] | ||||
| self.__filename_online = filename | ||||
| self.amisrFilePointer = h5py.File(filename,'r') | ||||
| self.flagIsNewFile = 1 | ||||
| self.filename = filename | ||||
| print "Setting the file: %s"%self.filename | ||||
| return 1 | ||||
|
Daniel Valdez
|
r491 | def __readHeader(self): | ||
| self.radacHeaderObj = RadacHeader(self.amisrFilePointer) | ||||
| #update values from experiment cfg file | ||||
| if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile: | ||||
| self.radacHeaderObj.nrecords = self.recordsperfile_fromfile | ||||
| self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile | ||||
| self.radacHeaderObj.npulses = self.npulsesint_fromfile | ||||
| self.radacHeaderObj.nsamples = self.ngates_fromfile | ||||
|
Daniel Valdez
|
r497 | #looking index list for data | ||
| start_index = self.radacHeaderObj.pulseCount[0,:][0] | ||||
| end_index = self.radacHeaderObj.npulses | ||||
| range4data = range(start_index, end_index) | ||||
| self.index4_schain_datablock = numpy.array(range4data) | ||||
| buffer_start_index = 0 | ||||
| buffer_end_index = self.radacHeaderObj.pulseCount[0,:][0] | ||||
| range4buffer = range(buffer_start_index, buffer_end_index) | ||||
| self.index4_buffer = numpy.array(range4buffer) | ||||
| self.linear_pulseCount = numpy.array(range4data + range4buffer) | ||||
| self.npulseByFrame = max(self.radacHeaderObj.pulseCount[0,:]+1) | ||||
|
Daniel Valdez
|
r491 | #get tuning frequency | ||
| frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency') | ||||
| self.frequency_h5file = frequency_h5file_dataset[0,0] | ||||
| self.flagIsNewFile = 1 | ||||
| def __getBeamCode(self): | ||||
| self.beamCodeDict = {} | ||||
| self.beamRangeDict = {} | ||||
|
Daniel Valdez
|
r499 | beamCodeMap = self.amisrFilePointer.get('Setup/BeamcodeMap') | ||
|
Daniel Valdez
|
r491 | for i in range(len(self.radacHeaderObj.beamCode[0,:])): | ||
| self.beamCodeDict.setdefault(i) | ||||
| self.beamRangeDict.setdefault(i) | ||||
|
Daniel Valdez
|
r499 | beamcodeValue = self.radacHeaderObj.beamCode[0,i] | ||
| beamcodeIndex = numpy.where(beamCodeMap[:,0] == beamcodeValue)[0][0] | ||||
| x = beamCodeMap[beamcodeIndex][1] | ||||
| y = beamCodeMap[beamcodeIndex][2] | ||||
| z = beamCodeMap[beamcodeIndex][3] | ||||
| self.beamCodeDict[i] = [beamcodeValue, x, y, z] | ||||
|
Daniel Valdez
|
r491 | |||
| just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:] | ||||
| for i in range(len(self.beamCodeDict.values())): | ||||
|
Daniel Valdez
|
r499 | xx = numpy.where(just4record0==self.beamCodeDict.values()[i][0]) | ||
|
Daniel Valdez
|
r504 | indexPulseByBeam = self.linear_pulseCount[xx[0]] | ||
| self.beamRangeDict[i] = indexPulseByBeam | ||||
|
Daniel Valdez
|
r491 | |||
| def __getExpParameters(self): | ||||
| if not(self.status): | ||||
| return None | ||||
| experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup') | ||||
| expFinder = glob.glob1(experimentCfgPath,'*.exp') | ||||
| if len(expFinder)== 0: | ||||
| self.status = 0 | ||||
| return None | ||||
| experimentFilename = os.path.join(experimentCfgPath,expFinder[0]) | ||||
| f = open(experimentFilename) | ||||
| lines = f.readlines() | ||||
| f.close() | ||||
| parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*'] | ||||
| filterList = [fnmatch.filter(lines, x) for x in parmsList] | ||||
| values = [re.sub(r'\D',"",x[0]) for x in filterList] | ||||
| self.npulsesint_fromfile = int(values[0]) | ||||
| self.recordsperfile_fromfile = int(values[1]) | ||||
| self.nbeamcodes_fromfile = int(values[2]) | ||||
| self.ngates_fromfile = int(values[3]) | ||||
| tufileFinder = fnmatch.filter(lines, 'tufile=*') | ||||
| tufile = tufileFinder[0].split('=')[1].split('\n')[0] | ||||
|
Daniel Valdez
|
r499 | tufile = tufile.split('\r')[0] | ||
|
Daniel Valdez
|
r491 | tufilename = os.path.join(experimentCfgPath,tufile) | ||
| f = open(tufilename) | ||||
| lines = f.readlines() | ||||
| f.close() | ||||
| self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6 | ||||
| self.status = 1 | ||||
| def __setIdsAndArrays(self): | ||||
| self.dataByFrame = self.__setDataByFrame() | ||||
| self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[0, :] | ||||
| self.readRanges() | ||||
|
Daniel Valdez
|
r497 | self.index_amisr_sample, self.index_amisr_buffer = self.radacHeaderObj.getIndexRangeToPulse(0) | ||
|
Daniel Valdez
|
r491 | self.radacTimeByFrame = numpy.zeros(self.radacHeaderObj.npulses) | ||
|
Daniel Valdez
|
r508 | if len(self.index_amisr_buffer) > 0: | ||
| self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame) | ||||
|
Daniel Valdez
|
r491 | |||
|
Daniel Valdez
|
r508 | def __setNextFile(self,online=False): | ||
|
Daniel Valdez
|
r491 | |||
|
Daniel Valdez
|
r508 | if not(online): | ||
| newFile = self.__setNextFileOffline() | ||||
| else: | ||||
| newFile = self.__setNextFileOnline() | ||||
|
Daniel Valdez
|
r491 | |||
| if not(newFile): | ||||
| return 0 | ||||
| self.__readHeader() | ||||
| if self.__firstFile: | ||||
| self.__setIdsAndArrays() | ||||
| self.__firstFile = False | ||||
| self.__getBeamCode() | ||||
| self.readDataBlock() | ||||
| def setup(self,path=None, | ||||
| startDate=None, | ||||
| endDate=None, | ||||
| startTime=datetime.time(0,0,0), | ||||
| endTime=datetime.time(23,59,59), | ||||
|
Daniel Valdez
|
r497 | walk=True, | ||
|
Daniel Valdez
|
r499 | timezone='ut', | ||
|
Daniel Valdez
|
r508 | all=0, | ||
| online=False): | ||||
|
Daniel Valdez
|
r491 | |||
|
Daniel Valdez
|
r497 | self.timezone = timezone | ||
|
Daniel Valdez
|
r499 | self.all = all | ||
|
Daniel Valdez
|
r508 | self.online = online | ||
| if not(online): | ||||
| #Busqueda de archivos offline | ||||
|
Juan C. Espinoza
|
r1052 | self.searchFilesOffLine(path, startDate, endDate, startTime, endTime, walk) | ||
|
Daniel Valdez
|
r508 | else: | ||
|
Juan C. Espinoza
|
r1052 | self.searchFilesOnLine(path, walk) | ||
|
Daniel Valdez
|
r491 | |||
| if not(self.filenameList): | ||||
| print "There is no files into the folder: %s"%(path) | ||||
| sys.exit(-1) | ||||
| self.__getExpParameters() | ||||
| self.fileIndex = -1 | ||||
|
Daniel Valdez
|
r508 | self.__setNextFile(online) | ||
|
Daniel Valdez
|
r497 | |||
|
Daniel Valdez
|
r504 | # first_beamcode = self.radacHeaderObj.beamCodeByPulse[0,0] | ||
| # index = numpy.where(self.radacHeaderObj.beamCodeByPulse[0,:]!=first_beamcode)[0][0] | ||||
| self.profileIndex_offset = self.radacHeaderObj.pulseCount[0,:][0] | ||||
|
Daniel Valdez
|
r497 | self.profileIndex = self.profileIndex_offset | ||
|
Daniel Valdez
|
r491 | |||
| def readRanges(self): | ||||
| dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range') | ||||
|
Daniel Valdez
|
r504 | |||
|
Daniel Valdez
|
r491 | self.rangeFromFile = numpy.reshape(dataset.value,(-1)) | ||
|
Daniel Valdez
|
r504 | return self.rangeFromFile | ||
|
Daniel Valdez
|
r491 | |||
| def readRadacTime(self,idrecord, range1, range2): | ||||
| self.radacTimeFromFile = self.radacHeaderObj.radacTime.value | ||||
| radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses)) | ||||
| #radacTimeByFrame = dataset[idrecord - 1,range1] | ||||
| #radacTimeByFrame = dataset[idrecord,range2] | ||||
| return radacTimeByFrame | ||||
| def readBeamCode(self, idrecord, range1, range2): | ||||
| dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode') | ||||
| beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses)) | ||||
| self.beamCodesFromFile = dataset.value | ||||
| #beamcodeByFrame[range1] = dataset[idrecord - 1, range1] | ||||
| #beamcodeByFrame[range2] = dataset[idrecord, range2] | ||||
| beamcodeByFrame[range1] = dataset[idrecord, range1] | ||||
| beamcodeByFrame[range2] = dataset[idrecord, range2] | ||||
| return beamcodeByFrame | ||||
| def __setDataByFrame(self): | ||||
| ndata = 2 # porque es complejo | ||||
| dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata)) | ||||
| return dataByFrame | ||||
| def __readDataSet(self): | ||||
| dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data') | ||||
| return dataset | ||||
| def __setDataBlock(self,): | ||||
| real = self.dataByFrame[:,:,0] #asumo que 0 es real | ||||
| imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario | ||||
| datablock = real + imag*1j #armo el complejo | ||||
| return datablock | ||||
| def readSamples_version1(self,idrecord): | ||||
| #estas tres primeras lineas solo se deben ejecutar una vez | ||||
| if self.flagIsNewFile: | ||||
| #reading dataset | ||||
| self.dataset = self.__readDataSet() | ||||
| self.flagIsNewFile = 0 | ||||
| if idrecord == 0: | ||||
|
Daniel Valdez
|
r497 | self.dataByFrame[self.index4_schain_datablock, : ,:] = self.dataset[0, self.index_amisr_sample,:,:] | ||
| self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[0, self.index_amisr_sample] | ||||
|
Daniel Valdez
|
r491 | datablock = self.__setDataBlock() | ||
|
Daniel Valdez
|
r508 | if len(self.index_amisr_buffer) > 0: | ||
| self.buffer = self.dataset[0, self.index_amisr_buffer,:,:] | ||||
| self.buffer_radactime = self.radacHeaderObj.radacTime[0, self.index_amisr_buffer] | ||||
|
Daniel Valdez
|
r497 | |||
|
Daniel Valdez
|
r491 | return datablock | ||
|
Daniel Valdez
|
r508 | if len(self.index_amisr_buffer) > 0: | ||
| self.dataByFrame[self.index4_buffer,:,:] = self.buffer.copy() | ||||
| self.radacTimeByFrame[self.index4_buffer] = self.buffer_radactime.copy() | ||||
|
Daniel Valdez
|
r497 | self.dataByFrame[self.index4_schain_datablock,:,:] = self.dataset[idrecord, self.index_amisr_sample,:,:] | ||
| self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_sample] | ||||
| datablock = self.__setDataBlock() | ||||
|
Daniel Valdez
|
r508 | if len(self.index_amisr_buffer) > 0: | ||
| self.buffer = self.dataset[idrecord, self.index_amisr_buffer, :, :] | ||||
| self.buffer_radactime = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_buffer] | ||||
|
Daniel Valdez
|
r491 | |||
| return datablock | ||||
| def readSamples(self,idrecord): | ||||
| if self.flagIsNewFile: | ||||
| self.dataByFrame = self.__setDataByFrame() | ||||
| self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :] | ||||
| #reading ranges | ||||
| self.readRanges() | ||||
| #reading dataset | ||||
| self.dataset = self.__readDataSet() | ||||
| self.flagIsNewFile = 0 | ||||
| self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :] | ||||
| self.dataByFrame = self.dataset[idrecord, :, :, :] | ||||
| datablock = self.__setDataBlock() | ||||
| return datablock | ||||
| def readDataBlock(self): | ||||
| self.datablock = self.readSamples_version1(self.idrecord_count) | ||||
| #self.datablock = self.readSamples(self.idrecord_count) | ||||
| #print 'record:', self.idrecord_count | ||||
| self.idrecord_count += 1 | ||||
| self.profileIndex = 0 | ||||
| if self.idrecord_count >= self.radacHeaderObj.nrecords: | ||||
| self.idrecord_count = 0 | ||||
| self.flagIsNewFile = 1 | ||||
| def readNextBlock(self): | ||||
| self.readDataBlock() | ||||
| if self.flagIsNewFile: | ||||
|
Daniel Valdez
|
r508 | self.__setNextFile(self.online) | ||
|
Daniel Valdez
|
r491 | pass | ||
| def __hasNotDataInBuffer(self): | ||||
| #self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record | ||||
| if self.profileIndex >= self.radacHeaderObj.npulses: | ||||
| return 1 | ||||
| return 0 | ||||
| def printUTC(self): | ||||
| print self.dataOut.utctime | ||||
| print '' | ||||
| def setObjProperties(self): | ||||
|
Miguel Valdez
|
r527 | |||
|
Daniel Valdez
|
r491 | self.dataOut.heightList = self.rangeFromFile/1000.0 #km | ||
| self.dataOut.nProfiles = self.radacHeaderObj.npulses | ||||
| self.dataOut.nRecords = self.radacHeaderObj.nrecords | ||||
| self.dataOut.nBeams = self.radacHeaderObj.nbeams | ||||
| self.dataOut.ippSeconds = self.ippSeconds_fromfile | ||||
|
Miguel Valdez
|
r527 | # self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt | ||
|
Daniel Valdez
|
r491 | self.dataOut.frequency = self.frequency_h5file | ||
|
Daniel Valdez
|
r497 | self.dataOut.npulseByFrame = self.npulseByFrame | ||
|
Daniel Valdez
|
r491 | self.dataOut.nBaud = None | ||
| self.dataOut.nCode = None | ||||
| self.dataOut.code = None | ||||
| self.dataOut.beamCodeDict = self.beamCodeDict | ||||
| self.dataOut.beamRangeDict = self.beamRangeDict | ||||
|
Daniel Valdez
|
r497 | |||
| if self.timezone == 'lt': | ||||
| self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes | ||||
| else: | ||||
| self.dataOut.timeZone = 0 #by default time is UTC | ||||
|
Daniel Valdez
|
r491 | def getData(self): | ||
| if self.flagNoMoreFiles: | ||||
| self.dataOut.flagNoData = True | ||||
| print 'Process finished' | ||||
| return 0 | ||||
| if self.__hasNotDataInBuffer(): | ||||
| self.readNextBlock() | ||||
|
Miguel Valdez
|
r611 | if self.datablock is None: # setear esta condicion cuando no hayan datos por leers | ||
|
Daniel Valdez
|
r491 | self.dataOut.flagNoData = True | ||
| return 0 | ||||
| self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1)) | ||||
| self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex] | ||||
|
Daniel Valdez
|
r501 | self.dataOut.profileIndex = self.profileIndex | ||
|
Daniel Valdez
|
r491 | self.dataOut.flagNoData = False | ||
| self.profileIndex += 1 | ||||
| return self.dataOut.data | ||||
| def run(self, **kwargs): | ||||
| if not(self.isConfig): | ||||
| self.setup(**kwargs) | ||||
| self.setObjProperties() | ||||
| self.isConfig = True | ||||
| self.getData() | ||||