| @@ -1,616 +1,617 | |||||
| 1 | ''' |
|
1 | ''' | |
| 2 | @author: Daniel Suarez |
|
2 | @author: Daniel Suarez | |
| 3 | ''' |
|
3 | ''' | |
| 4 |
|
4 | |||
| 5 | import os |
|
5 | import os | |
| 6 | import sys |
|
6 | import sys | |
| 7 | import glob |
|
7 | import glob | |
| 8 | import fnmatch |
|
8 | import fnmatch | |
| 9 | import datetime |
|
9 | import datetime | |
| 10 | import time |
|
10 | import time | |
| 11 | import re |
|
11 | import re | |
| 12 | import h5py |
|
12 | import h5py | |
| 13 | import numpy |
|
13 | import numpy | |
| 14 |
|
14 | |||
| 15 | from model.proc.jroproc_base import ProcessingUnit, Operation |
|
15 | from model.proc.jroproc_base import ProcessingUnit, Operation | |
| 16 | from model.data.jroamisr import AMISR |
|
16 | from model.data.jroamisr import AMISR | |
| 17 |
|
17 | |||
| 18 | class RadacHeader(): |
|
18 | class RadacHeader(): | |
| 19 | def __init__(self, fp): |
|
19 | def __init__(self, fp): | |
| 20 | header = 'Raw11/Data/RadacHeader' |
|
20 | header = 'Raw11/Data/RadacHeader' | |
| 21 | self.beamCodeByPulse = fp.get(header+'/BeamCode') |
|
21 | self.beamCodeByPulse = fp.get(header+'/BeamCode') | |
| 22 | self.beamCode = fp.get('Raw11/Data/Beamcodes') |
|
22 | self.beamCode = fp.get('Raw11/Data/Beamcodes') | |
| 23 | self.code = fp.get(header+'/Code') |
|
23 | self.code = fp.get(header+'/Code') | |
| 24 | self.frameCount = fp.get(header+'/FrameCount') |
|
24 | self.frameCount = fp.get(header+'/FrameCount') | |
| 25 | self.modeGroup = fp.get(header+'/ModeGroup') |
|
25 | self.modeGroup = fp.get(header+'/ModeGroup') | |
| 26 | self.nsamplesPulse = fp.get(header+'/NSamplesPulse') |
|
26 | self.nsamplesPulse = fp.get(header+'/NSamplesPulse') | |
| 27 | self.pulseCount = fp.get(header+'/PulseCount') |
|
27 | self.pulseCount = fp.get(header+'/PulseCount') | |
| 28 | self.radacTime = fp.get(header+'/RadacTime') |
|
28 | self.radacTime = fp.get(header+'/RadacTime') | |
| 29 | self.timeCount = fp.get(header+'/TimeCount') |
|
29 | self.timeCount = fp.get(header+'/TimeCount') | |
| 30 | self.timeStatus = fp.get(header+'/TimeStatus') |
|
30 | self.timeStatus = fp.get(header+'/TimeStatus') | |
| 31 |
|
31 | |||
| 32 | self.nrecords = self.pulseCount.shape[0] #nblocks |
|
32 | self.nrecords = self.pulseCount.shape[0] #nblocks | |
| 33 | self.npulses = self.pulseCount.shape[1] #nprofile |
|
33 | self.npulses = self.pulseCount.shape[1] #nprofile | |
| 34 | self.nsamples = self.nsamplesPulse[0,0] #ngates |
|
34 | self.nsamples = self.nsamplesPulse[0,0] #ngates | |
| 35 | self.nbeams = self.beamCode.shape[1] |
|
35 | self.nbeams = self.beamCode.shape[1] | |
| 36 |
|
36 | |||
| 37 |
|
37 | |||
| 38 | def getIndexRangeToPulse(self, idrecord=0): |
|
38 | def getIndexRangeToPulse(self, idrecord=0): | |
| 39 | #indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0) |
|
39 | #indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0) | |
| 40 | #startPulseCountId = indexToZero[0][0] |
|
40 | #startPulseCountId = indexToZero[0][0] | |
| 41 | #endPulseCountId = startPulseCountId - 1 |
|
41 | #endPulseCountId = startPulseCountId - 1 | |
| 42 | #range1 = numpy.arange(startPulseCountId,self.npulses,1) |
|
42 | #range1 = numpy.arange(startPulseCountId,self.npulses,1) | |
| 43 | #range2 = numpy.arange(0,startPulseCountId,1) |
|
43 | #range2 = numpy.arange(0,startPulseCountId,1) | |
| 44 | #return range1, range2 |
|
44 | #return range1, range2 | |
| 45 |
|
45 | |||
| 46 | looking_zeros_index = numpy.where(self.pulseCount.value[idrecord,:]==0)[0] |
|
46 | looking_zeros_index = numpy.where(self.pulseCount.value[idrecord,:]==0)[0] | |
| 47 | getLastIndexZero = looking_zeros_index[-1] |
|
47 | getLastIndexZero = looking_zeros_index[-1] | |
| 48 | index_data = numpy.arange(0,getLastIndexZero,1) |
|
48 | index_data = numpy.arange(0,getLastIndexZero,1) | |
| 49 | index_buffer = numpy.arange(getLastIndexZero,self.npulses,1) |
|
49 | index_buffer = numpy.arange(getLastIndexZero,self.npulses,1) | |
| 50 | return index_data, index_buffer |
|
50 | return index_data, index_buffer | |
| 51 |
|
51 | |||
| 52 | class AMISRReader(ProcessingUnit): |
|
52 | class AMISRReader(ProcessingUnit): | |
| 53 |
|
53 | |||
| 54 | path = None |
|
54 | path = None | |
| 55 | startDate = None |
|
55 | startDate = None | |
| 56 | endDate = None |
|
56 | endDate = None | |
| 57 | startTime = None |
|
57 | startTime = None | |
| 58 | endTime = None |
|
58 | endTime = None | |
| 59 | walk = None |
|
59 | walk = None | |
| 60 | isConfig = False |
|
60 | isConfig = False | |
| 61 |
|
61 | |||
| 62 | def __init__(self): |
|
62 | def __init__(self): | |
| 63 | self.set = None |
|
63 | self.set = None | |
| 64 | self.subset = None |
|
64 | self.subset = None | |
| 65 | self.extension_file = '.h5' |
|
65 | self.extension_file = '.h5' | |
| 66 | self.dtc_str = 'dtc' |
|
66 | self.dtc_str = 'dtc' | |
| 67 | self.dtc_id = 0 |
|
67 | self.dtc_id = 0 | |
| 68 | self.status = True |
|
68 | self.status = True | |
| 69 | self.isConfig = False |
|
69 | self.isConfig = False | |
| 70 | self.dirnameList = [] |
|
70 | self.dirnameList = [] | |
| 71 | self.filenameList = [] |
|
71 | self.filenameList = [] | |
| 72 | self.fileIndex = None |
|
72 | self.fileIndex = None | |
| 73 | self.flagNoMoreFiles = False |
|
73 | self.flagNoMoreFiles = False | |
| 74 | self.flagIsNewFile = 0 |
|
74 | self.flagIsNewFile = 0 | |
| 75 | self.filename = '' |
|
75 | self.filename = '' | |
| 76 | self.amisrFilePointer = None |
|
76 | self.amisrFilePointer = None | |
| 77 | self.radacHeaderObj = None |
|
77 | self.radacHeaderObj = None | |
| 78 | self.dataOut = self.__createObjByDefault() |
|
78 | self.dataOut = self.__createObjByDefault() | |
| 79 | self.datablock = None |
|
79 | self.datablock = None | |
| 80 | self.rest_datablock = None |
|
80 | self.rest_datablock = None | |
| 81 | self.range = None |
|
81 | self.range = None | |
| 82 | self.idrecord_count = 0 |
|
82 | self.idrecord_count = 0 | |
| 83 | self.profileIndex = 0 |
|
83 | self.profileIndex = 0 | |
| 84 | self.index_amisr_sample = None |
|
84 | self.index_amisr_sample = None | |
| 85 | self.index_amisr_buffer = None |
|
85 | self.index_amisr_buffer = None | |
| 86 | self.beamCodeByFrame = None |
|
86 | self.beamCodeByFrame = None | |
| 87 | self.radacTimeByFrame = None |
|
87 | self.radacTimeByFrame = None | |
| 88 | #atributos originales tal y como esta en el archivo de datos |
|
88 | #atributos originales tal y como esta en el archivo de datos | |
| 89 | self.beamCodesFromFile = None |
|
89 | self.beamCodesFromFile = None | |
| 90 | self.radacTimeFromFile = None |
|
90 | self.radacTimeFromFile = None | |
| 91 | self.rangeFromFile = None |
|
91 | self.rangeFromFile = None | |
| 92 | self.dataByFrame = None |
|
92 | self.dataByFrame = None | |
| 93 | self.dataset = None |
|
93 | self.dataset = None | |
| 94 |
|
94 | |||
| 95 | self.beamCodeDict = {} |
|
95 | self.beamCodeDict = {} | |
| 96 | self.beamRangeDict = {} |
|
96 | self.beamRangeDict = {} | |
| 97 |
|
97 | |||
| 98 | #experiment cgf file |
|
98 | #experiment cgf file | |
| 99 | self.npulsesint_fromfile = None |
|
99 | self.npulsesint_fromfile = None | |
| 100 | self.recordsperfile_fromfile = None |
|
100 | self.recordsperfile_fromfile = None | |
| 101 | self.nbeamcodes_fromfile = None |
|
101 | self.nbeamcodes_fromfile = None | |
| 102 | self.ngates_fromfile = None |
|
102 | self.ngates_fromfile = None | |
| 103 | self.ippSeconds_fromfile = None |
|
103 | self.ippSeconds_fromfile = None | |
| 104 | self.frequency_h5file = None |
|
104 | self.frequency_h5file = None | |
| 105 |
|
105 | |||
| 106 |
|
106 | |||
| 107 | self.__firstFile = True |
|
107 | self.__firstFile = True | |
| 108 | self.buffer_radactime = None |
|
108 | self.buffer_radactime = None | |
| 109 |
|
109 | |||
| 110 | self.index4_schain_datablock = None |
|
110 | self.index4_schain_datablock = None | |
| 111 | self.index4_buffer = None |
|
111 | self.index4_buffer = None | |
| 112 | self.schain_datablock = None |
|
112 | self.schain_datablock = None | |
| 113 | self.buffer = None |
|
113 | self.buffer = None | |
| 114 | self.linear_pulseCount = None |
|
114 | self.linear_pulseCount = None | |
| 115 | self.npulseByFrame = None |
|
115 | self.npulseByFrame = None | |
| 116 | self.profileIndex_offset = None |
|
116 | self.profileIndex_offset = None | |
| 117 | self.timezone = 'ut' |
|
117 | self.timezone = 'ut' | |
| 118 |
|
118 | |||
| 119 | def __createObjByDefault(self): |
|
119 | def __createObjByDefault(self): | |
| 120 |
|
120 | |||
| 121 | dataObj = AMISR() |
|
121 | dataObj = AMISR() | |
| 122 |
|
122 | |||
| 123 | return dataObj |
|
123 | return dataObj | |
| 124 |
|
124 | |||
| 125 | def __setParameters(self,path,startDate,endDate,startTime,endTime,walk): |
|
125 | def __setParameters(self,path,startDate,endDate,startTime,endTime,walk): | |
| 126 | self.path = path |
|
126 | self.path = path | |
| 127 | self.startDate = startDate |
|
127 | self.startDate = startDate | |
| 128 | self.endDate = endDate |
|
128 | self.endDate = endDate | |
| 129 | self.startTime = startTime |
|
129 | self.startTime = startTime | |
| 130 | self.endTime = endTime |
|
130 | self.endTime = endTime | |
| 131 | self.walk = walk |
|
131 | self.walk = walk | |
| 132 |
|
132 | |||
| 133 | def __checkPath(self): |
|
133 | def __checkPath(self): | |
| 134 | if os.path.exists(self.path): |
|
134 | if os.path.exists(self.path): | |
| 135 | self.status = 1 |
|
135 | self.status = 1 | |
| 136 | else: |
|
136 | else: | |
| 137 | self.status = 0 |
|
137 | self.status = 0 | |
| 138 | print 'Path:%s does not exists'%self.path |
|
138 | print 'Path:%s does not exists'%self.path | |
| 139 |
|
139 | |||
| 140 | return |
|
140 | return | |
| 141 |
|
141 | |||
| 142 | def __selDates(self, amisr_dirname_format): |
|
142 | def __selDates(self, amisr_dirname_format): | |
| 143 | try: |
|
143 | try: | |
| 144 | year = int(amisr_dirname_format[0:4]) |
|
144 | year = int(amisr_dirname_format[0:4]) | |
| 145 | month = int(amisr_dirname_format[4:6]) |
|
145 | month = int(amisr_dirname_format[4:6]) | |
| 146 | dom = int(amisr_dirname_format[6:8]) |
|
146 | dom = int(amisr_dirname_format[6:8]) | |
| 147 | thisDate = datetime.date(year,month,dom) |
|
147 | thisDate = datetime.date(year,month,dom) | |
| 148 |
|
148 | |||
| 149 | if (thisDate>=self.startDate and thisDate <= self.endDate): |
|
149 | if (thisDate>=self.startDate and thisDate <= self.endDate): | |
| 150 | return amisr_dirname_format |
|
150 | return amisr_dirname_format | |
| 151 | except: |
|
151 | except: | |
| 152 | return None |
|
152 | return None | |
| 153 |
|
153 | |||
| 154 | def __findDataForDates(self): |
|
154 | def __findDataForDates(self): | |
| 155 |
|
155 | |||
| 156 |
|
156 | |||
| 157 |
|
157 | |||
| 158 | if not(self.status): |
|
158 | if not(self.status): | |
| 159 | return None |
|
159 | return None | |
| 160 |
|
160 | |||
| 161 | pat = '\d+.\d+' |
|
161 | pat = '\d+.\d+' | |
| 162 | dirnameList = [re.search(pat,x) for x in os.listdir(self.path)] |
|
162 | dirnameList = [re.search(pat,x) for x in os.listdir(self.path)] | |
| 163 | dirnameList = filter(lambda x:x!=None,dirnameList) |
|
163 | dirnameList = filter(lambda x:x!=None,dirnameList) | |
| 164 | dirnameList = [x.string for x in dirnameList] |
|
164 | dirnameList = [x.string for x in dirnameList] | |
| 165 | dirnameList = [self.__selDates(x) for x in dirnameList] |
|
165 | dirnameList = [self.__selDates(x) for x in dirnameList] | |
| 166 | dirnameList = filter(lambda x:x!=None,dirnameList) |
|
166 | dirnameList = filter(lambda x:x!=None,dirnameList) | |
| 167 | if len(dirnameList)>0: |
|
167 | if len(dirnameList)>0: | |
| 168 | self.status = 1 |
|
168 | self.status = 1 | |
| 169 | self.dirnameList = dirnameList |
|
169 | self.dirnameList = dirnameList | |
| 170 | self.dirnameList.sort() |
|
170 | self.dirnameList.sort() | |
| 171 | else: |
|
171 | else: | |
| 172 | self.status = 0 |
|
172 | self.status = 0 | |
| 173 | return None |
|
173 | return None | |
| 174 |
|
174 | |||
| 175 | def __getTimeFromData(self): |
|
175 | def __getTimeFromData(self): | |
| 176 | startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime) |
|
176 | startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime) | |
| 177 | endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime) |
|
177 | endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime) | |
| 178 |
|
178 | |||
| 179 | print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader) |
|
179 | print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader) | |
| 180 | print '........................................' |
|
180 | print '........................................' | |
| 181 | filter_filenameList = [] |
|
181 | filter_filenameList = [] | |
| 182 |
for |
|
182 | for i in range(len(self.filenameList)-1): | |
|
|
183 | filename = self.filenameList[i] | |||
| 183 | fp = h5py.File(filename,'r') |
|
184 | fp = h5py.File(filename,'r') | |
| 184 | time_str = fp.get('Time/RadacTimeString') |
|
185 | time_str = fp.get('Time/RadacTimeString') | |
| 185 |
|
186 | |||
| 186 | startDateTimeStr_File = time_str[0][0].split('.')[0] |
|
187 | startDateTimeStr_File = time_str[0][0].split('.')[0] | |
| 187 | junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S') |
|
188 | junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S') | |
| 188 | startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec) |
|
189 | startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec) | |
| 189 |
|
190 | |||
| 190 | endDateTimeStr_File = time_str[-1][-1].split('.')[0] |
|
191 | endDateTimeStr_File = time_str[-1][-1].split('.')[0] | |
| 191 | junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S') |
|
192 | junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S') | |
| 192 | endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec) |
|
193 | endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec) | |
| 193 |
|
194 | |||
| 194 | fp.close() |
|
195 | fp.close() | |
| 195 |
|
196 | |||
| 196 | if self.timezone == 'lt': |
|
197 | if self.timezone == 'lt': | |
| 197 | startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300) |
|
198 | startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300) | |
| 198 | endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300) |
|
199 | endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300) | |
| 199 |
|
200 | |||
| 200 | if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader): |
|
201 | if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader): | |
| 201 | #self.filenameList.remove(filename) |
|
202 | #self.filenameList.remove(filename) | |
| 202 | filter_filenameList.append(filename) |
|
203 | filter_filenameList.append(filename) | |
| 203 |
|
204 | |||
| 204 | filter_filenameList.sort() |
|
205 | filter_filenameList.sort() | |
| 205 | self.filenameList = filter_filenameList |
|
206 | self.filenameList = filter_filenameList | |
| 206 | return 1 |
|
207 | return 1 | |
| 207 |
|
208 | |||
| 208 | def __filterByGlob1(self, dirName): |
|
209 | def __filterByGlob1(self, dirName): | |
| 209 | filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file) |
|
210 | filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file) | |
| 210 | filterDict = {} |
|
211 | filterDict = {} | |
| 211 | filterDict.setdefault(dirName) |
|
212 | filterDict.setdefault(dirName) | |
| 212 | filterDict[dirName] = filter_files |
|
213 | filterDict[dirName] = filter_files | |
| 213 | return filterDict |
|
214 | return filterDict | |
| 214 |
|
215 | |||
| 215 | def __getFilenameList(self, fileListInKeys, dirList): |
|
216 | def __getFilenameList(self, fileListInKeys, dirList): | |
| 216 | for value in fileListInKeys: |
|
217 | for value in fileListInKeys: | |
| 217 | dirName = value.keys()[0] |
|
218 | dirName = value.keys()[0] | |
| 218 | for file in value[dirName]: |
|
219 | for file in value[dirName]: | |
| 219 | filename = os.path.join(dirName, file) |
|
220 | filename = os.path.join(dirName, file) | |
| 220 | self.filenameList.append(filename) |
|
221 | self.filenameList.append(filename) | |
| 221 |
|
222 | |||
| 222 |
|
223 | |||
| 223 | def __selectDataForTimes(self): |
|
224 | def __selectDataForTimes(self): | |
| 224 | #aun no esta implementado el filtro for tiempo |
|
225 | #aun no esta implementado el filtro for tiempo | |
| 225 | if not(self.status): |
|
226 | if not(self.status): | |
| 226 | return None |
|
227 | return None | |
| 227 |
|
228 | |||
| 228 | dirList = [os.path.join(self.path,x) for x in self.dirnameList] |
|
229 | dirList = [os.path.join(self.path,x) for x in self.dirnameList] | |
| 229 |
|
230 | |||
| 230 | fileListInKeys = [self.__filterByGlob1(x) for x in dirList] |
|
231 | fileListInKeys = [self.__filterByGlob1(x) for x in dirList] | |
| 231 |
|
232 | |||
| 232 | self.__getFilenameList(fileListInKeys, dirList) |
|
233 | self.__getFilenameList(fileListInKeys, dirList) | |
| 233 | #filtro por tiempo |
|
234 | #filtro por tiempo | |
| 234 | if not(self.all): |
|
235 | if not(self.all): | |
| 235 | self.__getTimeFromData() |
|
236 | self.__getTimeFromData() | |
| 236 |
|
237 | |||
| 237 |
|
238 | |||
| 238 | if len(self.filenameList)>0: |
|
239 | if len(self.filenameList)>0: | |
| 239 | self.status = 1 |
|
240 | self.status = 1 | |
| 240 | self.filenameList.sort() |
|
241 | self.filenameList.sort() | |
| 241 | else: |
|
242 | else: | |
| 242 | self.status = 0 |
|
243 | self.status = 0 | |
| 243 | return None |
|
244 | return None | |
| 244 |
|
245 | |||
| 245 |
|
246 | |||
| 246 | def __searchFilesOffline(self, |
|
247 | def __searchFilesOffline(self, | |
| 247 | path, |
|
248 | path, | |
| 248 | startDate, |
|
249 | startDate, | |
| 249 | endDate, |
|
250 | endDate, | |
| 250 | startTime=datetime.time(0,0,0), |
|
251 | startTime=datetime.time(0,0,0), | |
| 251 | endTime=datetime.time(23,59,59), |
|
252 | endTime=datetime.time(23,59,59), | |
| 252 | walk=True): |
|
253 | walk=True): | |
| 253 |
|
254 | |||
| 254 | self.__setParameters(path, startDate, endDate, startTime, endTime, walk) |
|
255 | self.__setParameters(path, startDate, endDate, startTime, endTime, walk) | |
| 255 |
|
256 | |||
| 256 | self.__checkPath() |
|
257 | self.__checkPath() | |
| 257 |
|
258 | |||
| 258 | self.__findDataForDates() |
|
259 | self.__findDataForDates() | |
| 259 |
|
260 | |||
| 260 | self.__selectDataForTimes() |
|
261 | self.__selectDataForTimes() | |
| 261 |
|
262 | |||
| 262 | for i in range(len(self.filenameList)): |
|
263 | for i in range(len(self.filenameList)): | |
| 263 | print "%s" %(self.filenameList[i]) |
|
264 | print "%s" %(self.filenameList[i]) | |
| 264 |
|
265 | |||
| 265 | return |
|
266 | return | |
| 266 |
|
267 | |||
| 267 | def __setNextFileOffline(self): |
|
268 | def __setNextFileOffline(self): | |
| 268 | idFile = self.fileIndex |
|
269 | idFile = self.fileIndex | |
| 269 |
|
270 | |||
| 270 | while (True): |
|
271 | while (True): | |
| 271 | idFile += 1 |
|
272 | idFile += 1 | |
| 272 | if not(idFile < len(self.filenameList)): |
|
273 | if not(idFile < len(self.filenameList)): | |
| 273 | self.flagNoMoreFiles = 1 |
|
274 | self.flagNoMoreFiles = 1 | |
| 274 | print "No more Files" |
|
275 | print "No more Files" | |
| 275 | return 0 |
|
276 | return 0 | |
| 276 |
|
277 | |||
| 277 | filename = self.filenameList[idFile] |
|
278 | filename = self.filenameList[idFile] | |
| 278 |
|
279 | |||
| 279 | amisrFilePointer = h5py.File(filename,'r') |
|
280 | amisrFilePointer = h5py.File(filename,'r') | |
| 280 |
|
281 | |||
| 281 | break |
|
282 | break | |
| 282 |
|
283 | |||
| 283 | self.flagIsNewFile = 1 |
|
284 | self.flagIsNewFile = 1 | |
| 284 | self.fileIndex = idFile |
|
285 | self.fileIndex = idFile | |
| 285 | self.filename = filename |
|
286 | self.filename = filename | |
| 286 |
|
287 | |||
| 287 | self.amisrFilePointer = amisrFilePointer |
|
288 | self.amisrFilePointer = amisrFilePointer | |
| 288 |
|
289 | |||
| 289 | print "Setting the file: %s"%self.filename |
|
290 | print "Setting the file: %s"%self.filename | |
| 290 |
|
291 | |||
| 291 | return 1 |
|
292 | return 1 | |
| 292 |
|
293 | |||
| 293 | def __readHeader(self): |
|
294 | def __readHeader(self): | |
| 294 | self.radacHeaderObj = RadacHeader(self.amisrFilePointer) |
|
295 | self.radacHeaderObj = RadacHeader(self.amisrFilePointer) | |
| 295 |
|
296 | |||
| 296 | #update values from experiment cfg file |
|
297 | #update values from experiment cfg file | |
| 297 | if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile: |
|
298 | if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile: | |
| 298 | self.radacHeaderObj.nrecords = self.recordsperfile_fromfile |
|
299 | self.radacHeaderObj.nrecords = self.recordsperfile_fromfile | |
| 299 | self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile |
|
300 | self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile | |
| 300 | self.radacHeaderObj.npulses = self.npulsesint_fromfile |
|
301 | self.radacHeaderObj.npulses = self.npulsesint_fromfile | |
| 301 | self.radacHeaderObj.nsamples = self.ngates_fromfile |
|
302 | self.radacHeaderObj.nsamples = self.ngates_fromfile | |
| 302 |
|
303 | |||
| 303 | #looking index list for data |
|
304 | #looking index list for data | |
| 304 | start_index = self.radacHeaderObj.pulseCount[0,:][0] |
|
305 | start_index = self.radacHeaderObj.pulseCount[0,:][0] | |
| 305 | end_index = self.radacHeaderObj.npulses |
|
306 | end_index = self.radacHeaderObj.npulses | |
| 306 | range4data = range(start_index, end_index) |
|
307 | range4data = range(start_index, end_index) | |
| 307 | self.index4_schain_datablock = numpy.array(range4data) |
|
308 | self.index4_schain_datablock = numpy.array(range4data) | |
| 308 |
|
309 | |||
| 309 | buffer_start_index = 0 |
|
310 | buffer_start_index = 0 | |
| 310 | buffer_end_index = self.radacHeaderObj.pulseCount[0,:][0] |
|
311 | buffer_end_index = self.radacHeaderObj.pulseCount[0,:][0] | |
| 311 | range4buffer = range(buffer_start_index, buffer_end_index) |
|
312 | range4buffer = range(buffer_start_index, buffer_end_index) | |
| 312 | self.index4_buffer = numpy.array(range4buffer) |
|
313 | self.index4_buffer = numpy.array(range4buffer) | |
| 313 |
|
314 | |||
| 314 | self.linear_pulseCount = numpy.array(range4data + range4buffer) |
|
315 | self.linear_pulseCount = numpy.array(range4data + range4buffer) | |
| 315 | self.npulseByFrame = max(self.radacHeaderObj.pulseCount[0,:]+1) |
|
316 | self.npulseByFrame = max(self.radacHeaderObj.pulseCount[0,:]+1) | |
| 316 |
|
317 | |||
| 317 | #get tuning frequency |
|
318 | #get tuning frequency | |
| 318 | frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency') |
|
319 | frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency') | |
| 319 | self.frequency_h5file = frequency_h5file_dataset[0,0] |
|
320 | self.frequency_h5file = frequency_h5file_dataset[0,0] | |
| 320 |
|
321 | |||
| 321 | self.flagIsNewFile = 1 |
|
322 | self.flagIsNewFile = 1 | |
| 322 |
|
323 | |||
| 323 | def __getBeamCode(self): |
|
324 | def __getBeamCode(self): | |
| 324 | self.beamCodeDict = {} |
|
325 | self.beamCodeDict = {} | |
| 325 | self.beamRangeDict = {} |
|
326 | self.beamRangeDict = {} | |
| 326 |
|
327 | |||
| 327 | beamCodeMap = self.amisrFilePointer.get('Setup/BeamcodeMap') |
|
328 | beamCodeMap = self.amisrFilePointer.get('Setup/BeamcodeMap') | |
| 328 |
|
329 | |||
| 329 | for i in range(len(self.radacHeaderObj.beamCode[0,:])): |
|
330 | for i in range(len(self.radacHeaderObj.beamCode[0,:])): | |
| 330 | self.beamCodeDict.setdefault(i) |
|
331 | self.beamCodeDict.setdefault(i) | |
| 331 | self.beamRangeDict.setdefault(i) |
|
332 | self.beamRangeDict.setdefault(i) | |
| 332 | beamcodeValue = self.radacHeaderObj.beamCode[0,i] |
|
333 | beamcodeValue = self.radacHeaderObj.beamCode[0,i] | |
| 333 | beamcodeIndex = numpy.where(beamCodeMap[:,0] == beamcodeValue)[0][0] |
|
334 | beamcodeIndex = numpy.where(beamCodeMap[:,0] == beamcodeValue)[0][0] | |
| 334 | x = beamCodeMap[beamcodeIndex][1] |
|
335 | x = beamCodeMap[beamcodeIndex][1] | |
| 335 | y = beamCodeMap[beamcodeIndex][2] |
|
336 | y = beamCodeMap[beamcodeIndex][2] | |
| 336 | z = beamCodeMap[beamcodeIndex][3] |
|
337 | z = beamCodeMap[beamcodeIndex][3] | |
| 337 | self.beamCodeDict[i] = [beamcodeValue, x, y, z] |
|
338 | self.beamCodeDict[i] = [beamcodeValue, x, y, z] | |
| 338 |
|
339 | |||
| 339 | just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:] |
|
340 | just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:] | |
| 340 |
|
341 | |||
| 341 | for i in range(len(self.beamCodeDict.values())): |
|
342 | for i in range(len(self.beamCodeDict.values())): | |
| 342 | xx = numpy.where(just4record0==self.beamCodeDict.values()[i][0]) |
|
343 | xx = numpy.where(just4record0==self.beamCodeDict.values()[i][0]) | |
| 343 | self.beamRangeDict[i] = xx[0] |
|
344 | self.beamRangeDict[i] = xx[0] | |
| 344 |
|
345 | |||
| 345 | def __getExpParameters(self): |
|
346 | def __getExpParameters(self): | |
| 346 | if not(self.status): |
|
347 | if not(self.status): | |
| 347 | return None |
|
348 | return None | |
| 348 |
|
349 | |||
| 349 | experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup') |
|
350 | experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup') | |
| 350 |
|
351 | |||
| 351 | expFinder = glob.glob1(experimentCfgPath,'*.exp') |
|
352 | expFinder = glob.glob1(experimentCfgPath,'*.exp') | |
| 352 | if len(expFinder)== 0: |
|
353 | if len(expFinder)== 0: | |
| 353 | self.status = 0 |
|
354 | self.status = 0 | |
| 354 | return None |
|
355 | return None | |
| 355 |
|
356 | |||
| 356 | experimentFilename = os.path.join(experimentCfgPath,expFinder[0]) |
|
357 | experimentFilename = os.path.join(experimentCfgPath,expFinder[0]) | |
| 357 |
|
358 | |||
| 358 | f = open(experimentFilename) |
|
359 | f = open(experimentFilename) | |
| 359 | lines = f.readlines() |
|
360 | lines = f.readlines() | |
| 360 | f.close() |
|
361 | f.close() | |
| 361 |
|
362 | |||
| 362 | parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*'] |
|
363 | parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*'] | |
| 363 | filterList = [fnmatch.filter(lines, x) for x in parmsList] |
|
364 | filterList = [fnmatch.filter(lines, x) for x in parmsList] | |
| 364 |
|
365 | |||
| 365 |
|
366 | |||
| 366 | values = [re.sub(r'\D',"",x[0]) for x in filterList] |
|
367 | values = [re.sub(r'\D',"",x[0]) for x in filterList] | |
| 367 |
|
368 | |||
| 368 | self.npulsesint_fromfile = int(values[0]) |
|
369 | self.npulsesint_fromfile = int(values[0]) | |
| 369 | self.recordsperfile_fromfile = int(values[1]) |
|
370 | self.recordsperfile_fromfile = int(values[1]) | |
| 370 | self.nbeamcodes_fromfile = int(values[2]) |
|
371 | self.nbeamcodes_fromfile = int(values[2]) | |
| 371 | self.ngates_fromfile = int(values[3]) |
|
372 | self.ngates_fromfile = int(values[3]) | |
| 372 |
|
373 | |||
| 373 | tufileFinder = fnmatch.filter(lines, 'tufile=*') |
|
374 | tufileFinder = fnmatch.filter(lines, 'tufile=*') | |
| 374 | tufile = tufileFinder[0].split('=')[1].split('\n')[0] |
|
375 | tufile = tufileFinder[0].split('=')[1].split('\n')[0] | |
| 375 | tufile = tufile.split('\r')[0] |
|
376 | tufile = tufile.split('\r')[0] | |
| 376 | tufilename = os.path.join(experimentCfgPath,tufile) |
|
377 | tufilename = os.path.join(experimentCfgPath,tufile) | |
| 377 |
|
378 | |||
| 378 | f = open(tufilename) |
|
379 | f = open(tufilename) | |
| 379 | lines = f.readlines() |
|
380 | lines = f.readlines() | |
| 380 | f.close() |
|
381 | f.close() | |
| 381 | self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6 |
|
382 | self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6 | |
| 382 |
|
383 | |||
| 383 |
|
384 | |||
| 384 | self.status = 1 |
|
385 | self.status = 1 | |
| 385 |
|
386 | |||
| 386 | def __setIdsAndArrays(self): |
|
387 | def __setIdsAndArrays(self): | |
| 387 | self.dataByFrame = self.__setDataByFrame() |
|
388 | self.dataByFrame = self.__setDataByFrame() | |
| 388 | self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[0, :] |
|
389 | self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[0, :] | |
| 389 | self.readRanges() |
|
390 | self.readRanges() | |
| 390 | self.index_amisr_sample, self.index_amisr_buffer = self.radacHeaderObj.getIndexRangeToPulse(0) |
|
391 | self.index_amisr_sample, self.index_amisr_buffer = self.radacHeaderObj.getIndexRangeToPulse(0) | |
| 391 | self.radacTimeByFrame = numpy.zeros(self.radacHeaderObj.npulses) |
|
392 | self.radacTimeByFrame = numpy.zeros(self.radacHeaderObj.npulses) | |
| 392 | self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame) |
|
393 | self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame) | |
| 393 |
|
394 | |||
| 394 |
|
395 | |||
| 395 | def __setNextFile(self): |
|
396 | def __setNextFile(self): | |
| 396 |
|
397 | |||
| 397 | newFile = self.__setNextFileOffline() |
|
398 | newFile = self.__setNextFileOffline() | |
| 398 |
|
399 | |||
| 399 | if not(newFile): |
|
400 | if not(newFile): | |
| 400 | return 0 |
|
401 | return 0 | |
| 401 |
|
402 | |||
| 402 | self.__readHeader() |
|
403 | self.__readHeader() | |
| 403 |
|
404 | |||
| 404 | if self.__firstFile: |
|
405 | if self.__firstFile: | |
| 405 | self.__setIdsAndArrays() |
|
406 | self.__setIdsAndArrays() | |
| 406 | self.__firstFile = False |
|
407 | self.__firstFile = False | |
| 407 |
|
408 | |||
| 408 | self.__getBeamCode() |
|
409 | self.__getBeamCode() | |
| 409 | self.readDataBlock() |
|
410 | self.readDataBlock() | |
| 410 |
|
411 | |||
| 411 |
|
412 | |||
| 412 | def setup(self,path=None, |
|
413 | def setup(self,path=None, | |
| 413 | startDate=None, |
|
414 | startDate=None, | |
| 414 | endDate=None, |
|
415 | endDate=None, | |
| 415 | startTime=datetime.time(0,0,0), |
|
416 | startTime=datetime.time(0,0,0), | |
| 416 | endTime=datetime.time(23,59,59), |
|
417 | endTime=datetime.time(23,59,59), | |
| 417 | walk=True, |
|
418 | walk=True, | |
| 418 | timezone='ut', |
|
419 | timezone='ut', | |
| 419 | all=0,): |
|
420 | all=0,): | |
| 420 |
|
421 | |||
| 421 | self.timezone = timezone |
|
422 | self.timezone = timezone | |
| 422 | self.all = all |
|
423 | self.all = all | |
| 423 | #Busqueda de archivos offline |
|
424 | #Busqueda de archivos offline | |
| 424 | self.__searchFilesOffline(path, startDate, endDate, startTime, endTime, walk) |
|
425 | self.__searchFilesOffline(path, startDate, endDate, startTime, endTime, walk) | |
| 425 |
|
426 | |||
| 426 | if not(self.filenameList): |
|
427 | if not(self.filenameList): | |
| 427 | print "There is no files into the folder: %s"%(path) |
|
428 | print "There is no files into the folder: %s"%(path) | |
| 428 |
|
429 | |||
| 429 | sys.exit(-1) |
|
430 | sys.exit(-1) | |
| 430 |
|
431 | |||
| 431 | self.__getExpParameters() |
|
432 | self.__getExpParameters() | |
| 432 |
|
433 | |||
| 433 | self.fileIndex = -1 |
|
434 | self.fileIndex = -1 | |
| 434 |
|
435 | |||
| 435 | self.__setNextFile() |
|
436 | self.__setNextFile() | |
| 436 |
|
437 | |||
| 437 | first_beamcode = self.radacHeaderObj.beamCodeByPulse[0,0] |
|
438 | first_beamcode = self.radacHeaderObj.beamCodeByPulse[0,0] | |
| 438 | index = numpy.where(self.radacHeaderObj.beamCodeByPulse[0,:]!=first_beamcode)[0][0] |
|
439 | index = numpy.where(self.radacHeaderObj.beamCodeByPulse[0,:]!=first_beamcode)[0][0] | |
| 439 | self.profileIndex_offset = self.radacHeaderObj.pulseCount[0,:][index] |
|
440 | self.profileIndex_offset = self.radacHeaderObj.pulseCount[0,:][index] | |
| 440 | self.profileIndex = self.profileIndex_offset |
|
441 | self.profileIndex = self.profileIndex_offset | |
| 441 |
|
442 | |||
| 442 | def readRanges(self): |
|
443 | def readRanges(self): | |
| 443 | dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range') |
|
444 | dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range') | |
| 444 | #self.rangeFromFile = dataset.value |
|
445 | #self.rangeFromFile = dataset.value | |
| 445 | self.rangeFromFile = numpy.reshape(dataset.value,(-1)) |
|
446 | self.rangeFromFile = numpy.reshape(dataset.value,(-1)) | |
| 446 | return range |
|
447 | return range | |
| 447 |
|
448 | |||
| 448 |
|
449 | |||
| 449 | def readRadacTime(self,idrecord, range1, range2): |
|
450 | def readRadacTime(self,idrecord, range1, range2): | |
| 450 | self.radacTimeFromFile = self.radacHeaderObj.radacTime.value |
|
451 | self.radacTimeFromFile = self.radacHeaderObj.radacTime.value | |
| 451 |
|
452 | |||
| 452 | radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses)) |
|
453 | radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses)) | |
| 453 | #radacTimeByFrame = dataset[idrecord - 1,range1] |
|
454 | #radacTimeByFrame = dataset[idrecord - 1,range1] | |
| 454 | #radacTimeByFrame = dataset[idrecord,range2] |
|
455 | #radacTimeByFrame = dataset[idrecord,range2] | |
| 455 |
|
456 | |||
| 456 | return radacTimeByFrame |
|
457 | return radacTimeByFrame | |
| 457 |
|
458 | |||
| 458 | def readBeamCode(self, idrecord, range1, range2): |
|
459 | def readBeamCode(self, idrecord, range1, range2): | |
| 459 | dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode') |
|
460 | dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode') | |
| 460 | beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses)) |
|
461 | beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses)) | |
| 461 | self.beamCodesFromFile = dataset.value |
|
462 | self.beamCodesFromFile = dataset.value | |
| 462 |
|
463 | |||
| 463 | #beamcodeByFrame[range1] = dataset[idrecord - 1, range1] |
|
464 | #beamcodeByFrame[range1] = dataset[idrecord - 1, range1] | |
| 464 | #beamcodeByFrame[range2] = dataset[idrecord, range2] |
|
465 | #beamcodeByFrame[range2] = dataset[idrecord, range2] | |
| 465 | beamcodeByFrame[range1] = dataset[idrecord, range1] |
|
466 | beamcodeByFrame[range1] = dataset[idrecord, range1] | |
| 466 | beamcodeByFrame[range2] = dataset[idrecord, range2] |
|
467 | beamcodeByFrame[range2] = dataset[idrecord, range2] | |
| 467 |
|
468 | |||
| 468 | return beamcodeByFrame |
|
469 | return beamcodeByFrame | |
| 469 |
|
470 | |||
| 470 |
|
471 | |||
| 471 | def __setDataByFrame(self): |
|
472 | def __setDataByFrame(self): | |
| 472 | ndata = 2 # porque es complejo |
|
473 | ndata = 2 # porque es complejo | |
| 473 | dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata)) |
|
474 | dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata)) | |
| 474 | return dataByFrame |
|
475 | return dataByFrame | |
| 475 |
|
476 | |||
| 476 | def __readDataSet(self): |
|
477 | def __readDataSet(self): | |
| 477 | dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data') |
|
478 | dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data') | |
| 478 | return dataset |
|
479 | return dataset | |
| 479 |
|
480 | |||
| 480 | def __setDataBlock(self,): |
|
481 | def __setDataBlock(self,): | |
| 481 | real = self.dataByFrame[:,:,0] #asumo que 0 es real |
|
482 | real = self.dataByFrame[:,:,0] #asumo que 0 es real | |
| 482 | imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario |
|
483 | imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario | |
| 483 | datablock = real + imag*1j #armo el complejo |
|
484 | datablock = real + imag*1j #armo el complejo | |
| 484 | return datablock |
|
485 | return datablock | |
| 485 |
|
486 | |||
| 486 | def readSamples_version1(self,idrecord): |
|
487 | def readSamples_version1(self,idrecord): | |
| 487 | #estas tres primeras lineas solo se deben ejecutar una vez |
|
488 | #estas tres primeras lineas solo se deben ejecutar una vez | |
| 488 | if self.flagIsNewFile: |
|
489 | if self.flagIsNewFile: | |
| 489 | #reading dataset |
|
490 | #reading dataset | |
| 490 | self.dataset = self.__readDataSet() |
|
491 | self.dataset = self.__readDataSet() | |
| 491 | self.flagIsNewFile = 0 |
|
492 | self.flagIsNewFile = 0 | |
| 492 |
|
493 | |||
| 493 | if idrecord == 0: |
|
494 | if idrecord == 0: | |
| 494 | self.dataByFrame[self.index4_schain_datablock, : ,:] = self.dataset[0, self.index_amisr_sample,:,:] |
|
495 | self.dataByFrame[self.index4_schain_datablock, : ,:] = self.dataset[0, self.index_amisr_sample,:,:] | |
| 495 | self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[0, self.index_amisr_sample] |
|
496 | self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[0, self.index_amisr_sample] | |
| 496 | datablock = self.__setDataBlock() |
|
497 | datablock = self.__setDataBlock() | |
| 497 |
|
498 | |||
| 498 | self.buffer = self.dataset[0, self.index_amisr_buffer,:,:] |
|
499 | self.buffer = self.dataset[0, self.index_amisr_buffer,:,:] | |
| 499 | self.buffer_radactime = self.radacHeaderObj.radacTime[0, self.index_amisr_buffer] |
|
500 | self.buffer_radactime = self.radacHeaderObj.radacTime[0, self.index_amisr_buffer] | |
| 500 |
|
501 | |||
| 501 | return datablock |
|
502 | return datablock | |
| 502 |
|
503 | |||
| 503 | self.dataByFrame[self.index4_buffer,:,:] = self.buffer.copy() |
|
504 | self.dataByFrame[self.index4_buffer,:,:] = self.buffer.copy() | |
| 504 | self.radacTimeByFrame[self.index4_buffer] = self.buffer_radactime.copy() |
|
505 | self.radacTimeByFrame[self.index4_buffer] = self.buffer_radactime.copy() | |
| 505 | self.dataByFrame[self.index4_schain_datablock,:,:] = self.dataset[idrecord, self.index_amisr_sample,:,:] |
|
506 | self.dataByFrame[self.index4_schain_datablock,:,:] = self.dataset[idrecord, self.index_amisr_sample,:,:] | |
| 506 | self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_sample] |
|
507 | self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_sample] | |
| 507 | datablock = self.__setDataBlock() |
|
508 | datablock = self.__setDataBlock() | |
| 508 |
|
509 | |||
| 509 | self.buffer = self.dataset[idrecord, self.index_amisr_buffer, :, :] |
|
510 | self.buffer = self.dataset[idrecord, self.index_amisr_buffer, :, :] | |
| 510 | self.buffer_radactime = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_buffer] |
|
511 | self.buffer_radactime = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_buffer] | |
| 511 |
|
512 | |||
| 512 | return datablock |
|
513 | return datablock | |
| 513 |
|
514 | |||
| 514 |
|
515 | |||
| 515 | def readSamples(self,idrecord): |
|
516 | def readSamples(self,idrecord): | |
| 516 | if self.flagIsNewFile: |
|
517 | if self.flagIsNewFile: | |
| 517 | self.dataByFrame = self.__setDataByFrame() |
|
518 | self.dataByFrame = self.__setDataByFrame() | |
| 518 | self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :] |
|
519 | self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :] | |
| 519 |
|
520 | |||
| 520 | #reading ranges |
|
521 | #reading ranges | |
| 521 | self.readRanges() |
|
522 | self.readRanges() | |
| 522 | #reading dataset |
|
523 | #reading dataset | |
| 523 | self.dataset = self.__readDataSet() |
|
524 | self.dataset = self.__readDataSet() | |
| 524 |
|
525 | |||
| 525 | self.flagIsNewFile = 0 |
|
526 | self.flagIsNewFile = 0 | |
| 526 | self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :] |
|
527 | self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :] | |
| 527 | self.dataByFrame = self.dataset[idrecord, :, :, :] |
|
528 | self.dataByFrame = self.dataset[idrecord, :, :, :] | |
| 528 | datablock = self.__setDataBlock() |
|
529 | datablock = self.__setDataBlock() | |
| 529 | return datablock |
|
530 | return datablock | |
| 530 |
|
531 | |||
| 531 |
|
532 | |||
| 532 | def readDataBlock(self): |
|
533 | def readDataBlock(self): | |
| 533 |
|
534 | |||
| 534 | self.datablock = self.readSamples_version1(self.idrecord_count) |
|
535 | self.datablock = self.readSamples_version1(self.idrecord_count) | |
| 535 | #self.datablock = self.readSamples(self.idrecord_count) |
|
536 | #self.datablock = self.readSamples(self.idrecord_count) | |
| 536 | #print 'record:', self.idrecord_count |
|
537 | #print 'record:', self.idrecord_count | |
| 537 |
|
538 | |||
| 538 | self.idrecord_count += 1 |
|
539 | self.idrecord_count += 1 | |
| 539 | self.profileIndex = 0 |
|
540 | self.profileIndex = 0 | |
| 540 |
|
541 | |||
| 541 | if self.idrecord_count >= self.radacHeaderObj.nrecords: |
|
542 | if self.idrecord_count >= self.radacHeaderObj.nrecords: | |
| 542 | self.idrecord_count = 0 |
|
543 | self.idrecord_count = 0 | |
| 543 | self.flagIsNewFile = 1 |
|
544 | self.flagIsNewFile = 1 | |
| 544 |
|
545 | |||
| 545 | def readNextBlock(self): |
|
546 | def readNextBlock(self): | |
| 546 |
|
547 | |||
| 547 | self.readDataBlock() |
|
548 | self.readDataBlock() | |
| 548 |
|
549 | |||
| 549 | if self.flagIsNewFile: |
|
550 | if self.flagIsNewFile: | |
| 550 | self.__setNextFile() |
|
551 | self.__setNextFile() | |
| 551 | pass |
|
552 | pass | |
| 552 |
|
553 | |||
| 553 | def __hasNotDataInBuffer(self): |
|
554 | def __hasNotDataInBuffer(self): | |
| 554 | #self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record |
|
555 | #self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record | |
| 555 | if self.profileIndex >= self.radacHeaderObj.npulses: |
|
556 | if self.profileIndex >= self.radacHeaderObj.npulses: | |
| 556 | return 1 |
|
557 | return 1 | |
| 557 | return 0 |
|
558 | return 0 | |
| 558 |
|
559 | |||
| 559 | def printUTC(self): |
|
560 | def printUTC(self): | |
| 560 | print self.dataOut.utctime |
|
561 | print self.dataOut.utctime | |
| 561 | print '' |
|
562 | print '' | |
| 562 |
|
563 | |||
| 563 | def setObjProperties(self): |
|
564 | def setObjProperties(self): | |
| 564 | self.dataOut.heightList = self.rangeFromFile/1000.0 #km |
|
565 | self.dataOut.heightList = self.rangeFromFile/1000.0 #km | |
| 565 | self.dataOut.nProfiles = self.radacHeaderObj.npulses |
|
566 | self.dataOut.nProfiles = self.radacHeaderObj.npulses | |
| 566 | self.dataOut.nRecords = self.radacHeaderObj.nrecords |
|
567 | self.dataOut.nRecords = self.radacHeaderObj.nrecords | |
| 567 | self.dataOut.nBeams = self.radacHeaderObj.nbeams |
|
568 | self.dataOut.nBeams = self.radacHeaderObj.nbeams | |
| 568 | self.dataOut.ippSeconds = self.ippSeconds_fromfile |
|
569 | self.dataOut.ippSeconds = self.ippSeconds_fromfile | |
| 569 | self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt |
|
570 | self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt | |
| 570 | self.dataOut.frequency = self.frequency_h5file |
|
571 | self.dataOut.frequency = self.frequency_h5file | |
| 571 | self.dataOut.npulseByFrame = self.npulseByFrame |
|
572 | self.dataOut.npulseByFrame = self.npulseByFrame | |
| 572 | self.dataOut.nBaud = None |
|
573 | self.dataOut.nBaud = None | |
| 573 | self.dataOut.nCode = None |
|
574 | self.dataOut.nCode = None | |
| 574 | self.dataOut.code = None |
|
575 | self.dataOut.code = None | |
| 575 |
|
576 | |||
| 576 | self.dataOut.beamCodeDict = self.beamCodeDict |
|
577 | self.dataOut.beamCodeDict = self.beamCodeDict | |
| 577 | self.dataOut.beamRangeDict = self.beamRangeDict |
|
578 | self.dataOut.beamRangeDict = self.beamRangeDict | |
| 578 |
|
579 | |||
| 579 | if self.timezone == 'lt': |
|
580 | if self.timezone == 'lt': | |
| 580 | self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes |
|
581 | self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes | |
| 581 | else: |
|
582 | else: | |
| 582 | self.dataOut.timeZone = 0 #by default time is UTC |
|
583 | self.dataOut.timeZone = 0 #by default time is UTC | |
| 583 |
|
584 | |||
| 584 | def getData(self): |
|
585 | def getData(self): | |
| 585 |
|
586 | |||
| 586 | if self.flagNoMoreFiles: |
|
587 | if self.flagNoMoreFiles: | |
| 587 | self.dataOut.flagNoData = True |
|
588 | self.dataOut.flagNoData = True | |
| 588 | print 'Process finished' |
|
589 | print 'Process finished' | |
| 589 | return 0 |
|
590 | return 0 | |
| 590 |
|
591 | |||
| 591 | if self.__hasNotDataInBuffer(): |
|
592 | if self.__hasNotDataInBuffer(): | |
| 592 | self.readNextBlock() |
|
593 | self.readNextBlock() | |
| 593 |
|
594 | |||
| 594 |
|
595 | |||
| 595 | if self.datablock == None: # setear esta condicion cuando no hayan datos por leers |
|
596 | if self.datablock == None: # setear esta condicion cuando no hayan datos por leers | |
| 596 | self.dataOut.flagNoData = True |
|
597 | self.dataOut.flagNoData = True | |
| 597 | return 0 |
|
598 | return 0 | |
| 598 |
|
599 | |||
| 599 | self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1)) |
|
600 | self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1)) | |
| 600 |
|
601 | |||
| 601 | self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex] |
|
602 | self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex] | |
| 602 |
|
603 | |||
| 603 | self.dataOut.flagNoData = False |
|
604 | self.dataOut.flagNoData = False | |
| 604 |
|
605 | |||
| 605 | self.profileIndex += 1 |
|
606 | self.profileIndex += 1 | |
| 606 |
|
607 | |||
| 607 | return self.dataOut.data |
|
608 | return self.dataOut.data | |
| 608 |
|
609 | |||
| 609 |
|
610 | |||
| 610 | def run(self, **kwargs): |
|
611 | def run(self, **kwargs): | |
| 611 | if not(self.isConfig): |
|
612 | if not(self.isConfig): | |
| 612 | self.setup(**kwargs) |
|
613 | self.setup(**kwargs) | |
| 613 | self.setObjProperties() |
|
614 | self.setObjProperties() | |
| 614 | self.isConfig = True |
|
615 | self.isConfig = True | |
| 615 |
|
616 | |||
| 616 | self.getData() |
|
617 | self.getData() | |
General Comments 0
You need to be logged in to leave comments.
Login now