##// END OF EJS Templates
schain
RSS
Se añadio dos atributos a la clase de lectura de voltajes: nReadBlocks y flagIsNewBlock.
Miguel Valdez -
r13:9243316017ec
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,34 +1,35
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author: danielangelsuarezmunoz
4 @author: danielangelsuarezmunoz
5 '''
5 '''
6
6
7 import Voltage
7 import Voltage
8 import datetime
8 import datetime
9 import time
9 import time, datetime
10
10
11 objReader = Voltage.VoltageReader()
11 objReader = Voltage.VoltageReader()
12
12
13
13
14 path = '/home/roj-idl71/Data/RAWDATA/DP_Faraday/'
14 path = '/home/roj-idl71/Data/RAWDATA/DP_Faraday/'
15 #path = '/remote/puma/2011_03/DP_Faraday'
15 #path = '/remote/puma/2011_03/DP_Faraday'
16
16
17
17
18 startDateTime = datetime.datetime(2011,3,11,16,0,0)
18 startDateTime = datetime.datetime(2011,3,11,16,40,0)
19 endDateTime = datetime.datetime(2011,3,12,20,1,0)
19 endDateTime = datetime.datetime(2011,3,11,16,59,0)
20
20
21 t0 = time.time()
21 t0 = time.time()
22 objReader.setup(path, startDateTime, endDateTime)
22 objReader.setup(path, startDateTime, endDateTime)
23 print time.time() - t0
23 print time.time() - t0
24
24
25
25
26 while(not(objReader.noMoreFiles)):
26 while(not(objReader.noMoreFiles)):
27
27
28 objReader.getData()
28 objReader.getData()
29 # if objReader.flagIsNewFile:
29 if objReader.flagIsNewBlock:
30 print "Block No %04d, Time: %s" %(objReader.nReadBlocks, datetime.datetime.fromtimestamp(objReader.m_BasicHeader.utc))
30 # print objReader.m_BasicHeader.dataBlock
31 # print objReader.m_BasicHeader.dataBlock
31 #print objReader.objStructShortHeader.dataBlock
32 #print objReader.objStructShortHeader.dataBlock
32 #print time.localtime(objReader.m_BasicHeader.utc)
33
33
34
34 No newline at end of file
35
Show file before | Show file after | Hide comments
@@ -1,445 +1,454
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author: danielangelsuarezmunoz
4 @author: danielangelsuarezmunoz
5 '''
5 '''
6
6
7
7
8 import os, sys
8 import os, sys
9 import numpy
9 import numpy
10 import glob
10 import glob
11 import fnmatch
11 import fnmatch
12 import time
12 import time
13 import datetime
13 import datetime
14
14
15 from Header import *
15 from Header import *
16 from Data import DataReader
16 from Data import DataReader
17 from Data import DataWriter
17 from Data import DataWriter
18
18
19 path = os.path.split(os.getcwd())[0]
19 path = os.path.split(os.getcwd())[0]
20 sys.path.append(path)
20 sys.path.append(path)
21
21
22 from Model.Voltage import Voltage
22 from Model.Voltage import Voltage
23
23
24 class VoltageReader(DataReader):
24 class VoltageReader(DataReader):
25
25
26 __idFile = None
26 __idFile = None
27
27
28 __fp = None
28 __fp = None
29
29
30 __startDateTime = None
30 __startDateTime = None
31
31
32 __endDateTime = None
32 __endDateTime = None
33
33
34 __dataType = None
34 __dataType = None
35
35
36 __fileSizeByHeader = 0
36 __fileSizeByHeader = 0
37
37
38 __pathList = []
38 __pathList = []
39
39
40 filenameList = []
40 filenameList = []
41
41
42 __lastUTTime = 0
42 __lastUTTime = 0
43
43
44 __maxTimeStep = 5
44 __maxTimeStep = 5
45
45
46 flagResetProcessing = 0
47
48 __flagIsNewFile = 0
46 __flagIsNewFile = 0
49
47
48 flagResetProcessing = 0
49
50 flagIsNewBlock = 0
51
50 noMoreFiles = 0
52 noMoreFiles = 0
51
53
54 nReadBlocks = 0
55
52 online = 0
56 online = 0
53
57
54 filename = None
58 filename = None
55
59
56 fileSize = None
60 fileSize = None
57
61
58 firstHeaderSize = 0
62 firstHeaderSize = 0
59
63
60 basicHeaderSize = 24
64 basicHeaderSize = 24
61
65
62 m_BasicHeader = BasicHeader()
66 m_BasicHeader = BasicHeader()
63
67
64 m_SystemHeader = SystemHeader()
68 m_SystemHeader = SystemHeader()
65
69
66 m_RadarControllerHeader = RadarControllerHeader()
70 m_RadarControllerHeader = RadarControllerHeader()
67
71
68 m_ProcessingHeader = ProcessingHeader()
72 m_ProcessingHeader = ProcessingHeader()
69
73
70 m_Voltage = None
74 m_Voltage = None
71
75
72 __buffer = 0
76 __buffer = 0
73
77
74 __buffer_id = 9999
78 __buffer_id = 9999
75
79
76 def __init__(self, m_Voltage = None):
80 def __init__(self, m_Voltage = None):
77
81
78 if m_Voltage == None:
82 if m_Voltage == None:
79 m_Voltage = Voltage()
83 m_Voltage = Voltage()
80
84
81 self.m_Voltage = m_Voltage
85 self.m_Voltage = m_Voltage
82
86
83 def __rdSystemHeader(self,fp=None):
87 def __rdSystemHeader(self,fp=None):
84 if fp == None:
88 if fp == None:
85 fp = self.__fp
89 fp = self.__fp
86
90
87 self.m_SystemHeader.read(fp)
91 self.m_SystemHeader.read(fp)
88
92
89 def __rdRadarControllerHeader(self,fp=None):
93 def __rdRadarControllerHeader(self,fp=None):
90 if fp == None:
94 if fp == None:
91 fp = self.__fp
95 fp = self.__fp
92
96
93 self.m_RadarControllerHeader.read(fp)
97 self.m_RadarControllerHeader.read(fp)
94
98
95 def __rdProcessingHeader(self,fp=None):
99 def __rdProcessingHeader(self,fp=None):
96 if fp == None:
100 if fp == None:
97 fp = self.__fp
101 fp = self.__fp
98
102
99 self.m_ProcessingHeader.read(fp)
103 self.m_ProcessingHeader.read(fp)
100
104
101 def __searchFiles(self,path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
105 def __searchFiles(self,path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
102
106
103 print "Searching files ..."
107 print "Searching files ..."
104
108
105 startUtSeconds = time.mktime(startDateTime.timetuple())
109 startUtSeconds = time.mktime(startDateTime.timetuple())
106 endUtSeconds = time.mktime(endDateTime.timetuple())
110 endUtSeconds = time.mktime(endDateTime.timetuple())
107
111
108 # startYear = startDateTime.timetuple().tm_year
112 # startYear = startDateTime.timetuple().tm_year
109 # endYear = endDateTime.timetuple().tm_year
113 # endYear = endDateTime.timetuple().tm_year
110 #
114 #
111 # startDoy = startDateTime.timetuple().tm_yday
115 # startDoy = startDateTime.timetuple().tm_yday
112 # endDoy = endDateTime.timetuple().tm_yday
116 # endDoy = endDateTime.timetuple().tm_yday
113 #
117 #
114 # yearRange = range(startYear,endYear+1)
118 # yearRange = range(startYear,endYear+1)
115 #
119 #
116 # doyDoubleList = []
120 # doyDoubleList = []
117 # if startYear == endYear:
121 # if startYear == endYear:
118 # doyList = range(startDoy,endDoy+1)
122 # doyList = range(startDoy,endDoy+1)
119 # else:
123 # else:
120 # for year in yearRange:
124 # for year in yearRange:
121 # if (year == startYear):
125 # if (year == startYear):
122 # doyDoubleList.append(range(startDoy,365+1))
126 # doyDoubleList.append(range(startDoy,365+1))
123 # elif (year == endYear):
127 # elif (year == endYear):
124 # doyDoubleList.append(range(1,endDoy+1))
128 # doyDoubleList.append(range(1,endDoy+1))
125 # else:
129 # else:
126 # doyDoubleList.append(range(1,365+1))
130 # doyDoubleList.append(range(1,365+1))
127 # doyList = []
131 # doyList = []
128 # for list in doyDoubleList:
132 # for list in doyDoubleList:
129 # doyList = doyList + list
133 # doyList = doyList + list
130 #
134 #
131 # dirList = []
135 # dirList = []
132 # for thisPath in os.listdir(path):
136 # for thisPath in os.listdir(path):
133 # if os.path.isdir(os.path.join(path,thisPath)):
137 # if os.path.isdir(os.path.join(path,thisPath)):
134 # #dirList.append(os.path.join(path,thisPath))
138 # #dirList.append(os.path.join(path,thisPath))
135 # dirList.append(thisPath)
139 # dirList.append(thisPath)
136 #
140 #
137 # pathList = []
141 # pathList = []
138 # pathDict = {}
142 # pathDict = {}
139 # for year in yearRange:
143 # for year in yearRange:
140 # for doy in doyList:
144 # for doy in doyList:
141 # match = fnmatch.filter(dirList, 'D' + '%4.4d%3.3d' % (year,doy))
145 # match = fnmatch.filter(dirList, 'D' + '%4.4d%3.3d' % (year,doy))
142 # if len(match) == 0:
146 # if len(match) == 0:
143 # match = fnmatch.filter(dirList, 'd' + '%4.4d%3.3d' % (year,doy))
147 # match = fnmatch.filter(dirList, 'd' + '%4.4d%3.3d' % (year,doy))
144 # if len(match) == 0: continue
148 # if len(match) == 0: continue
145 # if expLabel == '':
149 # if expLabel == '':
146 # pathList.append(os.path.join(path,match[0]))
150 # pathList.append(os.path.join(path,match[0]))
147 # pathDict.setdefault(os.path.join(path,match[0]))
151 # pathDict.setdefault(os.path.join(path,match[0]))
148 # pathDict[os.path.join(path,match[0])] = []
152 # pathDict[os.path.join(path,match[0])] = []
149 # else:
153 # else:
150 # pathList.append(os.path.join(path,os.path.join(match[0],expLabel)))
154 # pathList.append(os.path.join(path,os.path.join(match[0],expLabel)))
151 # pathDict.setdefault(os.path.join(path,os.path.join(match[0],expLabel)))
155 # pathDict.setdefault(os.path.join(path,os.path.join(match[0],expLabel)))
152 # pathDict[os.path.join(path,os.path.join(match[0],expLabel))] = []
156 # pathDict[os.path.join(path,os.path.join(match[0],expLabel))] = []
153
157
154
158
155 dirList = []
159 dirList = []
156 for thisPath in os.listdir(path):
160 for thisPath in os.listdir(path):
157 if os.path.isdir(os.path.join(path,thisPath)):
161 if os.path.isdir(os.path.join(path,thisPath)):
158 dirList.append(thisPath)
162 dirList.append(thisPath)
159
163
160 pathList = []
164 pathList = []
161
165
162 thisDateTime = startDateTime
166 thisDateTime = startDateTime
163
167
164 while(thisDateTime <= endDateTime):
168 while(thisDateTime <= endDateTime):
165 year = thisDateTime.timetuple().tm_year
169 year = thisDateTime.timetuple().tm_year
166 doy = thisDateTime.timetuple().tm_yday
170 doy = thisDateTime.timetuple().tm_yday
167
171
168 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
172 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
169 if len(match) == 0:
173 if len(match) == 0:
170 thisDateTime += datetime.timedelta(1)
174 thisDateTime += datetime.timedelta(1)
171 continue
175 continue
172
176
173 pathList.append(os.path.join(path,match[0],expLabel))
177 pathList.append(os.path.join(path,match[0],expLabel))
174 thisDateTime += datetime.timedelta(1)
178 thisDateTime += datetime.timedelta(1)
175
179
176 filenameList = []
180 filenameList = []
177 for thisPath in pathList:
181 for thisPath in pathList:
178 fileList = glob.glob1(thisPath, "*%s" %ext)
182 fileList = glob.glob1(thisPath, "*%s" %ext)
179 #pathDict[thisPath].append(fileList)
183 #pathDict[thisPath].append(fileList)
180 fileList.sort()
184 fileList.sort()
181 for file in fileList:
185 for file in fileList:
182 filename = os.path.join(thisPath,file)
186 filename = os.path.join(thisPath,file)
183 if self.isThisFileinRange(filename, startUtSeconds, endUtSeconds):
187 if self.isThisFileinRange(filename, startUtSeconds, endUtSeconds):
184 filenameList.append(filename)
188 filenameList.append(filename)
185
189
186 self.filenameList = filenameList
190 self.filenameList = filenameList
187
191
188 return pathList, filenameList
192 return pathList, filenameList
189
193
190 def isThisFileinRange(self, filename, startUTSeconds=None, endUTSeconds=None):
194 def isThisFileinRange(self, filename, startUTSeconds=None, endUTSeconds=None):
191
195
192 try:
196 try:
193 fp = open(filename,'rb')
197 fp = open(filename,'rb')
194 except:
198 except:
195 raise IOError, "The file %s can't be opened" %(filename)
199 raise IOError, "The file %s can't be opened" %(filename)
196
200
197 if startUTSeconds==None:
201 if startUTSeconds==None:
198 startUTSeconds = self.startUTCSeconds
202 startUTSeconds = self.startUTCSeconds
199
203
200 if endUTSeconds==None:
204 if endUTSeconds==None:
201 endUTSeconds = self.endUTCSeconds
205 endUTSeconds = self.endUTCSeconds
202
206
203 m_BasicHeader = BasicHeader()
207 m_BasicHeader = BasicHeader()
204
208
205 if not(m_BasicHeader.read(fp)):
209 if not(m_BasicHeader.read(fp)):
206 return 0
210 return 0
207
211
208 fp.close()
212 fp.close()
209
213
210 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
214 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
211 return 0
215 return 0
212
216
213 return 1
217 return 1
214
218
215 def __readBasicHeader(self, fp=None):
219 def __readBasicHeader(self, fp=None):
216
220
217 if fp == None:
221 if fp == None:
218 fp = self.__fp
222 fp = self.__fp
219
223
220 self.m_BasicHeader.read(fp)
224 self.m_BasicHeader.read(fp)
221
225
222 def __readFirstHeader(self):
226 def __readFirstHeader(self):
223
227
224 self.__readBasicHeader()
228 self.__readBasicHeader()
225 self.__rdSystemHeader()
229 self.__rdSystemHeader()
226 self.__rdRadarControllerHeader()
230 self.__rdRadarControllerHeader()
227 self.__rdProcessingHeader()
231 self.__rdProcessingHeader()
228 self.firstHeaderSize = self.m_BasicHeader.size
232 self.firstHeaderSize = self.m_BasicHeader.size
229
233
230 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
234 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
231 if data_type == 0:
235 if data_type == 0:
232 tmp=numpy.dtype([('real','<i1'),('imag','<i1')])
236 tmp=numpy.dtype([('real','<i1'),('imag','<i1')])
233 elif data_type == 1:
237 elif data_type == 1:
234 tmp=numpy.dtype([('real','<i2'),('imag','<i2')])
238 tmp=numpy.dtype([('real','<i2'),('imag','<i2')])
235 elif data_type == 2:
239 elif data_type == 2:
236 tmp=numpy.dtype([('real','<i4'),('imag','<i4')])
240 tmp=numpy.dtype([('real','<i4'),('imag','<i4')])
237 elif data_type == 3:
241 elif data_type == 3:
238 tmp=numpy.dtype([('real','<i8'),('imag','<i8')])
242 tmp=numpy.dtype([('real','<i8'),('imag','<i8')])
239 elif data_type == 4:
243 elif data_type == 4:
240 tmp=numpy.dtype([('real','<f4'),('imag','<f4')])
244 tmp=numpy.dtype([('real','<f4'),('imag','<f4')])
241 elif data_type == 5:
245 elif data_type == 5:
242 tmp=numpy.dtype([('real','<f8'),('imag','<f8')])
246 tmp=numpy.dtype([('real','<f8'),('imag','<f8')])
243 else:
247 else:
244 print 'no define data type'
248 raise ValueError, 'Data type was not defined'
245 tmp = 0
246
249
247 self.__dataType = tmp
250 self.__dataType = tmp
248 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
251 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
249
252
250 def __setNextFileOnline(self):
253 def __setNextFileOnline(self):
251 return 0
254 return 0
252
255
253 def __setNextFileOffline(self):
256 def __setNextFileOffline(self):
254
257
255 idFile = self.__idFile
258 idFile = self.__idFile
256 while(True):
259 while(True):
257
260
258 idFile += 1
261 idFile += 1
259
262
260 if not(idFile < len(self.filenameList)):
263 if not(idFile < len(self.filenameList)):
261 self.noMoreFiles = 1
264 self.noMoreFiles = 1
262 return 0
265 return 0
263
266
264 filename = self.filenameList[idFile]
267 filename = self.filenameList[idFile]
265 fileSize = os.path.getsize(filename)
268 fileSize = os.path.getsize(filename)
266 fp = open(filename,'rb')
269 fp = open(filename,'rb')
267
270
268 currentSize = fileSize - fp.tell()
271 currentSize = fileSize - fp.tell()
269 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
272 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
270
273
271 if (currentSize < neededSize):
274 if (currentSize < neededSize):
272 continue
275 continue
273
276
274 break
277 break
275
278
276 self.__flagIsNewFile = 1
279 self.__flagIsNewFile = 1
277 self.__idFile = idFile
280 self.__idFile = idFile
278 self.filename = filename
281 self.filename = filename
279 self.fileSize = fileSize
282 self.fileSize = fileSize
280 self.__fp = fp
283 self.__fp = fp
281
284
282 print 'Setting the file: %s'%self.filename
285 print 'Setting the file: %s'%self.filename
283
286
284 return 1
287 return 1
285
288
286 def __setNextFile(self):
289 def __setNextFile(self):
287
290
288 if self.online:
291 if self.online:
289 return self.__setNextFileOnline()
292 return self.__setNextFileOnline()
290 else:
293 else:
291 return self.__setNextFileOffline()
294 return self.__setNextFileOffline()
292
295
293 def __setNewBlock(self):
296 def __setNewBlock(self):
294
297
295 if self.__fp == None:
298 if self.__fp == None:
296 return 0
299 return 0
297
300
298 if self.__flagIsNewFile:
301 if self.__flagIsNewFile:
299 return 1
302 return 1
300
303
301 currentSize = self.fileSize - self.__fp.tell()
304 currentSize = self.fileSize - self.__fp.tell()
302 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
305 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
303
306
304 # Bloque Completo
307 # Bloque Completo
305 if (currentSize >= neededSize):
308 if (currentSize >= neededSize):
306 self.__readBasicHeader()
309 self.__readBasicHeader()
307 return 1
310 return 1
308
311
309 if not(self.__setNextFile()):
312 if not(self.__setNextFile()):
310 return 0
313 return 0
311
314
312 self.__readFirstHeader()
315 self.__readFirstHeader()
313
316
314 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
317 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
315
318
316 self.flagResetProcessing = 0
319 self.flagResetProcessing = 0
317 if deltaTime > self.__maxTimeStep:
320 if deltaTime > self.__maxTimeStep:
318 self.flagResetProcessing = 1
321 self.flagResetProcessing = 1
322 self.nReadBlocks = 0
319
323
320 return 1
324 return 1
321
325
322 def __readBlock(self):
326 def __readBlock(self):
323 """Lee el bloque de datos desde la posicion actual del puntero del archivo y
327 """Lee el bloque de datos desde la posicion actual del puntero del archivo y
324 actualiza todos los parametros relacionados al bloque de datos (data, time,
328 actualiza todos los parametros relacionados al bloque de datos (data, time,
325 etc). La data leida es almacenada en el buffer y el contador de datos leidos es
329 etc). La data leida es almacenada en el buffer y el contador de datos leidos es
326 seteado a 0
330 seteado a 0
327 """
331 """
328
332
329 pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
333 pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
330
334
331 data = numpy.fromfile(self.__fp,self.__dataType,pts2read)
335 data = numpy.fromfile(self.__fp,self.__dataType,pts2read)
332
336
333 data = data.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels))
337 data = data.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels))
334
338
335 self.__flagIsNewFile = 0
339 self.__flagIsNewFile = 0
336
340
341 self.flagIsNewBlock = 1
342
343 self.nReadBlocks += 1
344
337 self.__buffer = data
345 self.__buffer = data
338
346
339 self.__buffer_id = 0
347 self.__buffer_id = 0
340
348
341 def readNextBlock(self):
349 def readNextBlock(self):
342
350
343 if not(self.__setNewBlock()):
351 if not(self.__setNewBlock()):
344 return 0
352 return 0
345
353
346 self.__readBlock()
354 self.__readBlock()
347
355
348 self.__lastUTTime = self.m_BasicHeader.utc
356 self.__lastUTTime = self.m_BasicHeader.utc
349
357
350 return 1
358 return 1
351
359
352 def __hasNotDataInBuffer(self):
360 def __hasNotDataInBuffer(self):
353 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
361 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
354 return 1
362 return 1
355
363
356 return 0
364 return 0
357
365
358 def getData(self):
366 def getData(self):
359 """Obtiene un unidad de datos del buffer de lectura y es copiada a la clase "Voltage"
367 """Obtiene un unidad de datos del buffer de lectura y es copiada a la clase "Voltage"
360 con todos los parametros asociados a este. cuando no hay datos en el buffer de
368 con todos los parametros asociados a este. cuando no hay datos en el buffer de
361 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
369 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
362 """
370 """
363 self.flagResetProcessing = 0
371 self.flagResetProcessing = 0
372 self.flagIsNewBlock = 0
364
373
365 if self.__hasNotDataInBuffer():
374 if self.__hasNotDataInBuffer():
366 self.readNextBlock()
375 self.readNextBlock()
367
376
368 if self.noMoreFiles == 1:
377 if self.noMoreFiles == 1:
369 print 'Process finished'
378 print 'Process finished'
370 return None
379 return None
371
380
372 data = self.__buffer[self.__buffer_id,:,:]
381 data = self.__buffer[self.__buffer_id,:,:]
373 time = 111
382 time = 111
374
383
375 # self.m_Voltage.data = data
384 # self.m_Voltage.data = data
376 # self.m_Voltage.timeProfile = time
385 # self.m_Voltage.timeProfile = time
377 # self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
386 # self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
378 # self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
387 # self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
379 # self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
388 # self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
380 # self.m_Voltage.m_SystemHeader = self.m_systemHeader.copy()
389 # self.m_Voltage.m_SystemHeader = self.m_systemHeader.copy()
381
390
382 self.__buffer_id += 1
391 self.__buffer_id += 1
383
392
384 #call setData - to Data Object
393 #call setData - to Data Object
385
394
386 return data
395 return data
387
396
388
397
389 def setup(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r", online = 0):
398 def setup(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r", online = 0):
390
399
391 if online == 0:
400 if online == 0:
392 pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext)
401 pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext)
393
402
394 if len(filenameList) == 0:
403 if len(filenameList) == 0:
395 self.__fp = None
404 self.__fp = None
396 self.noMoreFiles = 1
405 self.noMoreFiles = 1
397 print 'Do not exist files in range: %s - %s'%(startDateTime.ctime(), endDateTime.ctime())
406 print 'Do not exist files in range: %s - %s'%(startDateTime.ctime(), endDateTime.ctime())
398 return 0
407 return 0
399
408
400 # for thisFile in filenameList:
409 # for thisFile in filenameList:
401 # print thisFile
410 # print thisFile
402
411
403 self.__idFile = -1
412 self.__idFile = -1
404
413
405 if not(self.__setNextFile()):
414 if not(self.__setNextFile()):
406 print "No more files"
415 print "No more files"
407 return 0
416 return 0
408
417
409 self.__readFirstHeader()
418 self.__readFirstHeader()
410
419
411 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
420 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
412 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
421 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
413
422
414 self.startYear = startDateTime.timetuple().tm_year
423 self.startYear = startDateTime.timetuple().tm_year
415 self.endYear = endDateTime.timetuple().tm_year
424 self.endYear = endDateTime.timetuple().tm_year
416
425
417 self.startDoy = startDateTime.timetuple().tm_yday
426 self.startDoy = startDateTime.timetuple().tm_yday
418 self.endDoy = endDateTime.timetuple().tm_yday
427 self.endDoy = endDateTime.timetuple().tm_yday
419 #call fillHeaderValues() - to Data Object
428 #call fillHeaderValues() - to Data Object
420
429
421 self.__pathList = pathList
430 self.__pathList = pathList
422 self.filenameList = filenameList
431 self.filenameList = filenameList
423 self.online = online
432 self.online = online
424
433
425 class VoltageWriter(DataWriter):
434 class VoltageWriter(DataWriter):
426
435
427 m_BasicHeader= BasicHeader()
436 m_BasicHeader= BasicHeader()
428
437
429
438
430 m_SystemHeader = SystemHeader()
439 m_SystemHeader = SystemHeader()
431
440
432
441
433 m_RadarControllerHeader = RadarControllerHeader()
442 m_RadarControllerHeader = RadarControllerHeader()
434
443
435
444
436 m_ProcessingHeader = ProcessingHeader()
445 m_ProcessingHeader = ProcessingHeader()
437
446
438 m_Voltage = None
447 m_Voltage = None
439
448
440 def __init__(self, m_Voltage):
449 def __init__(self, m_Voltage):
441
450
442 self.m_Voltage = m_Voltage
451 self.m_Voltage = m_Voltage
443
452
444
453
445 No newline at end of file
454
General Comments 0
You need to be logged in to leave comments. Login now