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