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