##// END OF EJS Templates
schain
RSS
Bug fixed: La variable de tiempo "utc" no estaba siendo actualizada
Miguel Valdez -
r75:9e4ac0840d6d
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,398 +1,397
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author $Author$
4 @author $Author$
5 @version $Id$
5 @version $Id$
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, datetime
12 import time, datetime
13
13
14 path = os.path.split(os.getcwd())[0]
14 path = os.path.split(os.getcwd())[0]
15 sys.path.append(path)
15 sys.path.append(path)
16
16
17 from Model.JROHeader import *
17 from Model.JROHeader import *
18 from Model.Voltage import Voltage
18 from Model.Voltage import Voltage
19
19
20 from IO.DataIO import JRODataReader
20 from IO.DataIO import JRODataReader
21 from IO.DataIO import JRODataWriter
21 from IO.DataIO import JRODataWriter
22
22
23
23
24 class VoltageReader(JRODataReader):
24 class VoltageReader(JRODataReader):
25 """
25 """
26 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
26 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
27 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
27 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
28 perfiles*alturas*canales) son almacenados en la variable "buffer".
28 perfiles*alturas*canales) son almacenados en la variable "buffer".
29
29
30 perfiles * alturas * canales
30 perfiles * alturas * canales
31
31
32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
33 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
33 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
34 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
34 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
35 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
35 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
36
36
37 Example:
37 Example:
38
38
39 dpath = "/home/myuser/data"
39 dpath = "/home/myuser/data"
40
40
41 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
41 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
42
42
43 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
43 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
44
44
45 readerObj = VoltageReader()
45 readerObj = VoltageReader()
46
46
47 readerObj.setup(dpath, startTime, endTime)
47 readerObj.setup(dpath, startTime, endTime)
48
48
49 while(True):
49 while(True):
50
50
51 #to get one profile
51 #to get one profile
52 profile = readerObj.getData()
52 profile = readerObj.getData()
53
53
54 #print the profile
54 #print the profile
55 print profile
55 print profile
56
56
57 #If you want to see all datablock
57 #If you want to see all datablock
58 print readerObj.datablock
58 print readerObj.datablock
59
59
60 if readerObj.flagNoMoreFiles:
60 if readerObj.flagNoMoreFiles:
61 break
61 break
62
62
63 """
63 """
64 m_DataObj = None
64 m_DataObj = None
65
65
66 idProfile = 0
66 idProfile = 0
67
67
68 datablock = None
68 datablock = None
69
69
70 pts2read = 0
70 pts2read = 0
71
71
72 utc = 0
72 utc = 0
73
73
74 ext = ".r"
74 ext = ".r"
75
75
76 optchar = "D"
76 optchar = "D"
77
77
78
78
79 def __init__(self, m_Voltage=None):
79 def __init__(self, m_Voltage=None):
80 """
80 """
81 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
81 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
82
82
83 Input:
83 Input:
84 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
84 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
85 almacenar un perfil de datos cada vez que se haga un requerimiento
85 almacenar un perfil de datos cada vez que se haga un requerimiento
86 (getData). El perfil sera obtenido a partir del buffer de datos,
86 (getData). El perfil sera obtenido a partir del buffer de datos,
87 si el buffer esta vacio se hara un nuevo proceso de lectura de un
87 si el buffer esta vacio se hara un nuevo proceso de lectura de un
88 bloque de datos.
88 bloque de datos.
89 Si este parametro no es pasado se creara uno internamente.
89 Si este parametro no es pasado se creara uno internamente.
90
90
91 Variables afectadas:
91 Variables afectadas:
92 self.m_DataObj
92 self.m_DataObj
93
93
94 Return:
94 Return:
95 None
95 None
96 """
96 """
97 if m_Voltage == None:
97 if m_Voltage == None:
98 m_Voltage = Voltage()
98 m_Voltage = Voltage()
99
99
100 if not(isinstance(m_Voltage, Voltage)):
100 if not(isinstance(m_Voltage, Voltage)):
101 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
101 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
102
102
103 self.m_DataObj = m_Voltage
103 self.m_DataObj = m_Voltage
104
104
105
105
106 def __hasNotDataInBuffer(self):
106 def __hasNotDataInBuffer(self):
107 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
107 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
108 return 1
108 return 1
109 return 0
109 return 0
110
110
111
111
112 def getBlockDimension(self):
112 def getBlockDimension(self):
113 """
113 """
114 Obtiene la cantidad de puntos a leer por cada bloque de datos
114 Obtiene la cantidad de puntos a leer por cada bloque de datos
115
115
116 Affected:
116 Affected:
117 self.pts2read
117 self.pts2read
118 self.blocksize
118 self.blocksize
119
119
120 Return:
120 Return:
121 None
121 None
122 """
122 """
123 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
123 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
124 self.blocksize = self.pts2read
124 self.blocksize = self.pts2read
125 self.m_DataObj.nProfiles = self.m_ProcessingHeader.profilesPerBlock
125 self.m_DataObj.nProfiles = self.m_ProcessingHeader.profilesPerBlock
126
126
127
127
128 def readBlock(self):
128 def readBlock(self):
129 """
129 """
130 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
130 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
131 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
131 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
132 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
132 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
133 es seteado a 0
133 es seteado a 0
134
134
135 Inputs:
135 Inputs:
136 None
136 None
137
137
138 Return:
138 Return:
139 None
139 None
140
140
141 Affected:
141 Affected:
142 self.datablockIndex
142 self.datablockIndex
143 self.datablock
143 self.datablock
144 self.flagIsNewFile
144 self.flagIsNewFile
145 self.idProfile
145 self.idProfile
146 self.flagIsNewBlock
146 self.flagIsNewBlock
147 self.nReadBlocks
147 self.nReadBlocks
148
148
149 Exceptions:
149 Exceptions:
150 Si un bloque leido no es un bloque valido
150 Si un bloque leido no es un bloque valido
151 """
151 """
152 blockOk_flag = False
152 blockOk_flag = False
153 fpointer = self.fp.tell()
153 fpointer = self.fp.tell()
154
154
155 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
155 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
156
156
157 if self.online:
157 if self.online:
158 if junk.size != self.blocksize:
158 if junk.size != self.blocksize:
159 for nTries in range( self.nTries ):
159 for nTries in range( self.nTries ):
160 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
160 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
161 time.sleep( self.delay )
161 time.sleep( self.delay )
162 self.fp.seek( fpointer )
162 self.fp.seek( fpointer )
163 fpointer = self.fp.tell()
163 fpointer = self.fp.tell()
164
164
165 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
165 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
166
166
167 if junk.size == self.blocksize:
167 if junk.size == self.blocksize:
168 blockOk_flag = True
168 blockOk_flag = True
169 break
169 break
170
170
171 if not( blockOk_flag ):
171 if not( blockOk_flag ):
172 return 0
172 return 0
173
173
174 try:
174 try:
175 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
175 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
176 except:
176 except:
177 print "Data file %s is invalid" % self.filename
177 print "Data file %s is invalid" % self.filename
178 return 0
178 return 0
179
179
180 junk = numpy.transpose(junk, (2,0,1))
180 junk = numpy.transpose(junk, (2,0,1))
181 self.datablock = junk['real'] + junk['imag']*1j
181 self.datablock = junk['real'] + junk['imag']*1j
182
182
183 self.datablockIndex = 0
183 self.datablockIndex = 0
184 self.flagIsNewFile = 0
184 self.flagIsNewFile = 0
185 self.idProfile = 0
185 self.idProfile = 0
186 self.flagIsNewBlock = 1
186 self.flagIsNewBlock = 1
187
187
188 self.nReadBlocks += 1
188 self.nReadBlocks += 1
189 self.nBlocks += 1
189 self.nBlocks += 1
190
190
191 return 1
191 return 1
192
192
193
193
194 def getData(self):
194 def getData(self):
195 """
195 """
196 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
196 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
197 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
197 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
198 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
198 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
199
199
200 Ademas incrementa el contador del buffer en 1.
200 Ademas incrementa el contador del buffer en 1.
201
201
202 Return:
202 Return:
203 data : retorna un perfil de voltages (alturas * canales) copiados desde el
203 data : retorna un perfil de voltages (alturas * canales) copiados desde el
204 buffer. Si no hay mas archivos a leer retorna None.
204 buffer. Si no hay mas archivos a leer retorna None.
205
205
206 Variables afectadas:
206 Variables afectadas:
207 self.m_DataObj
207 self.m_DataObj
208 self.datablockIndex
208 self.datablockIndex
209 self.idProfile
209 self.idProfile
210
210
211 Affected:
211 Affected:
212 self.m_DataObj
212 self.m_DataObj
213 self.datablockIndex
213 self.datablockIndex
214 self.flagResetProcessing
214 self.flagResetProcessing
215 self.flagIsNewBlock
215 self.flagIsNewBlock
216 self.idProfile
216 self.idProfile
217 """
217 """
218 if self.flagNoMoreFiles: return 0
218 if self.flagNoMoreFiles: return 0
219
219
220 self.flagResetProcessing = 0
220 self.flagResetProcessing = 0
221 self.flagIsNewBlock = 0
221 self.flagIsNewBlock = 0
222
222
223 if self.__hasNotDataInBuffer():
223 if self.__hasNotDataInBuffer():
224
224
225 if not( self.readNextBlock() ):
225 if not( self.readNextBlock() ):
226 self.setNextFile()
226 self.setNextFile()
227 return 0
227 return 0
228
228
229 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
229 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
230 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
230 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
231 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
231 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
232 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
232 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
233 self.m_DataObj.heights = self.heights
233 self.m_DataObj.heights = self.heights
234 self.m_DataObj.dataType = self.dataType
234 self.m_DataObj.dataType = self.dataType
235
235
236 if self.flagNoMoreFiles == 1:
236 if self.flagNoMoreFiles == 1:
237 print 'Process finished'
237 print 'Process finished'
238 return 0
238 return 0
239
239
240 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
240 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
241
241
242 if self.datablock == None:
242 if self.datablock == None:
243 self.m_DataObj.flagNoData = True
243 self.m_DataObj.flagNoData = True
244 return 0
244 return 0
245
245
246 time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
246 time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
247 self.utc = time
247 self.m_DataObj.m_BasicHeader.utc = time
248 #self.m_DataObj.m_BasicHeader.utc = time
249
248
250 self.m_DataObj.flagNoData = False
249 self.m_DataObj.flagNoData = False
251 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
250 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
252
251
253 self.m_DataObj.data = self.datablock[:,self.datablockIndex,:]
252 self.m_DataObj.data = self.datablock[:,self.datablockIndex,:]
254 self.m_DataObj.idProfile = self.idProfile
253 self.m_DataObj.idProfile = self.idProfile
255
254
256 self.datablockIndex += 1
255 self.datablockIndex += 1
257 self.idProfile += 1
256 self.idProfile += 1
258
257
259 #call setData - to Data Object
258 #call setData - to Data Object
260
259
261 return 1 #self.m_DataObj.data
260 return 1 #self.m_DataObj.data
262
261
263
262
264 class VoltageWriter( JRODataWriter ):
263 class VoltageWriter( JRODataWriter ):
265 """
264 """
266 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
265 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
267 de los datos siempre se realiza por bloques.
266 de los datos siempre se realiza por bloques.
268 """
267 """
269 __configHeaderFile = 'wrSetHeadet.txt'
268 __configHeaderFile = 'wrSetHeadet.txt'
270
269
271 m_DataObj = None
270 m_DataObj = None
272
271
273 ext = ".r"
272 ext = ".r"
274
273
275 optchar = "D"
274 optchar = "D"
276
275
277 datablock = None
276 datablock = None
278
277
279 datablockIndex = 0
278 datablockIndex = 0
280
279
281 shapeBuffer = None
280 shapeBuffer = None
282
281
283
282
284 def __init__(self, m_Voltage=None):
283 def __init__(self, m_Voltage=None):
285 """
284 """
286 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
285 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
287
286
288 Affected:
287 Affected:
289 self.m_DataObj
288 self.m_DataObj
290
289
291 Return: None
290 Return: None
292 """
291 """
293 if m_Voltage == None:
292 if m_Voltage == None:
294 m_Voltage = Voltage()
293 m_Voltage = Voltage()
295
294
296 if not( isinstance(m_Voltage, Voltage) ):
295 if not( isinstance(m_Voltage, Voltage) ):
297 raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
296 raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
298
297
299 self.m_DataObj = m_Voltage
298 self.m_DataObj = m_Voltage
300
299
301
300
302 def hasAllDataInBuffer(self):
301 def hasAllDataInBuffer(self):
303 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
302 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
304 return 1
303 return 1
305 return 0
304 return 0
306
305
307
306
308 def setBlockDimension(self):
307 def setBlockDimension(self):
309 """
308 """
310 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
309 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
311
310
312 Affected:
311 Affected:
313 self.shape_spc_Buffer
312 self.shape_spc_Buffer
314 self.shape_cspc_Buffer
313 self.shape_cspc_Buffer
315 self.shape_dc_Buffer
314 self.shape_dc_Buffer
316
315
317 Return: None
316 Return: None
318 """
317 """
319 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
318 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
320 self.m_ProcessingHeader.numHeights,
319 self.m_ProcessingHeader.numHeights,
321 self.m_SystemHeader.numChannels )
320 self.m_SystemHeader.numChannels )
322
321
323 self.datablock = numpy.zeros(self.m_SystemHeader.numChannels,
322 self.datablock = numpy.zeros(self.m_SystemHeader.numChannels,
324 self.m_ProcessingHeader.profilesPerBlock,
323 self.m_ProcessingHeader.profilesPerBlock,
325 self.m_ProcessingHeader.numHeights,
324 self.m_ProcessingHeader.numHeights,
326 numpy.dtype('complex'))
325 numpy.dtype('complex'))
327
326
328
327
329 def writeBlock(self):
328 def writeBlock(self):
330 """
329 """
331 Escribe el buffer en el file designado
330 Escribe el buffer en el file designado
332
331
333 Affected:
332 Affected:
334 self.datablockIndex
333 self.datablockIndex
335 self.flagIsNewFile
334 self.flagIsNewFile
336 self.flagIsNewBlock
335 self.flagIsNewBlock
337 self.nWriteBlocks
336 self.nWriteBlocks
338 self.blocksCounter
337 self.blocksCounter
339
338
340 Return: None
339 Return: None
341 """
340 """
342 data = numpy.zeros( self.shapeBuffer, self.dataType )
341 data = numpy.zeros( self.shapeBuffer, self.dataType )
343
342
344 junk = numpy.transpose(self.datablock, (1,2,0))
343 junk = numpy.transpose(self.datablock, (1,2,0))
345
344
346 data['real'] = junk.real
345 data['real'] = junk.real
347 data['imag'] = junk.imag
346 data['imag'] = junk.imag
348
347
349 data = data.reshape( (-1) )
348 data = data.reshape( (-1) )
350
349
351 data.tofile( self.fp )
350 data.tofile( self.fp )
352
351
353 self.datablock.fill(0)
352 self.datablock.fill(0)
354 self.datablockIndex = 0
353 self.datablockIndex = 0
355 self.flagIsNewFile = 0
354 self.flagIsNewFile = 0
356 self.flagIsNewBlock = 1
355 self.flagIsNewBlock = 1
357 self.nWriteBlocks += 1
356 self.nWriteBlocks += 1
358 self.blocksCounter += 1
357 self.blocksCounter += 1
359
358
360
359
361 def putData(self):
360 def putData(self):
362 """
361 """
363 Setea un bloque de datos y luego los escribe en un file
362 Setea un bloque de datos y luego los escribe en un file
364
363
365 Affected:
364 Affected:
366 self.flagIsNewBlock
365 self.flagIsNewBlock
367 self.datablockIndex
366 self.datablockIndex
368
367
369 Return:
368 Return:
370 0 : Si no hay data o no hay mas files que puedan escribirse
369 0 : Si no hay data o no hay mas files que puedan escribirse
371 1 : Si se escribio la data de un bloque en un file
370 1 : Si se escribio la data de un bloque en un file
372 """
371 """
373 self.flagIsNewBlock = 0
372 self.flagIsNewBlock = 0
374
373
375 if self.m_DataObj.flagNoData:
374 if self.m_DataObj.flagNoData:
376 return 0
375 return 0
377
376
378 if self.m_DataObj.flagResetProcessing:
377 if self.m_DataObj.flagResetProcessing:
379
378
380 self.datablock.fill(0)
379 self.datablock.fill(0)
381 self.datablockIndex = 0
380 self.datablockIndex = 0
382 self.setNextFile()
381 self.setNextFile()
383
382
384 self.datablock[:,self.datablockIndex,:] = self.m_DataObj.data
383 self.datablock[:,self.datablockIndex,:] = self.m_DataObj.data
385
384
386 self.datablockIndex += 1
385 self.datablockIndex += 1
387
386
388 if self.hasAllDataInBuffer():
387 if self.hasAllDataInBuffer():
389 #if self.flagIsNewFile:
388 #if self.flagIsNewFile:
390 self.getHeader()
389 self.getHeader()
391 self.writeNextBlock()
390 self.writeNextBlock()
392
391
393 if self.flagNoMoreFiles:
392 if self.flagNoMoreFiles:
394 #print 'Process finished'
393 #print 'Process finished'
395 return 0
394 return 0
396
395
397 return 1
396 return 1
398 No newline at end of file
397
General Comments 0
You need to be logged in to leave comments. Login now