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