##// END OF EJS Templates
schain-jc
RSS
Victor Sarmiento -
r31:65ff9cdd8241
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,950 +1,948
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 IO.HeaderIO import *
18 18 from IO.DataIO import DataReader
19 19 from IO.DataIO import DataWriter
20 20
21 21 from Model.Voltage import Voltage
22 22
23 23 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
24 24 """
25 25 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
26 26 o no dentro del rango de fecha especificado.
27 27
28 28 Inputs:
29 29 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
30 30
31 31 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
32 32 segundos contados desde 01/01/1970.
33 33 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
34 34 segundos contados desde 01/01/1970.
35 35
36 36 Return:
37 37 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
38 38 fecha especificado, de lo contrario retorna False.
39 39
40 40 Excepciones:
41 41 Si el archivo no existe o no puede ser abierto
42 42 Si la cabecera no puede ser leida.
43 43
44 44 """
45 45 m_BasicHeader = BasicHeader()
46 46
47 47 try:
48 48 fp = open(filename,'rb')
49 49 except:
50 50 raise IOError, "The file %s can't be opened" %(filename)
51 51
52 52 if not(m_BasicHeader.read(fp)):
53 53 raise IOError, "The file %s has not a valid header" %(filename)
54 54
55 55 fp.close()
56 56
57 57 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
58 58 return 0
59 59
60 60 return 1
61 61
62 62 class VoltageReader(DataReader):
63 63 """
64 64 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
65 65 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
66 66 perfiles*alturas*canales) son almacenados en la variable "buffer".
67 67
68 68 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
69 69 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
70 70 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
71 71 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
72 72
73 73 Example:
74 74
75 75 dpath = "/home/myuser/data"
76 76
77 77 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
78 78
79 79 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
80 80
81 81 readerObj = VoltageReader()
82 82
83 83 readerObj.setup(dpath, startTime, endTime)
84 84
85 85 while(True):
86 86
87 87 #to get one profile
88 88 profile = readerObj.getData()
89 89
90 90 #print the profile
91 91 print profile
92 92
93 93 #If you want to see all datablock
94 94 print readerObj.datablock
95 95
96 96 if readerObj.noMoreFiles:
97 97 break
98 98
99 99 """
100 100
101 101 #speed of light
102 102 __c = 3E8
103 103
104 104 def __init__(self, m_Voltage = None):
105 105 """
106 106 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
107 107
108 108 Input:
109 109 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
110 110 almacenar un perfil de datos cada vez que se haga un requerimiento
111 111 (getData). El perfil sera obtenido a partir del buffer de datos,
112 112 si el buffer esta vacio se hara un nuevo proceso de lectura de un
113 113 bloque de datos.
114 114 Si este parametro no es pasado se creara uno internamente.
115 115
116 116 Variables afectadas:
117 117 self.m_Voltage
118 118 self.m_BasicHeader
119 119 self.m_SystemHeader
120 120 self.m_RadarControllerHeader
121 121 self.m_ProcessingHeader
122 122
123 123
124 124 Return:
125 125 Void
126 126
127 127 """
128 128 if m_Voltage == None:
129 129 m_Voltage = Voltage()
130 130
131 131 if not(isinstance(m_Voltage, Voltage)):
132 132 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
133 133
134 134 self.m_Voltage = m_Voltage
135 135
136 136 self.m_BasicHeader = BasicHeader()
137 137
138 138 self.m_SystemHeader = SystemHeader()
139 139
140 140 self.m_RadarControllerHeader = RadarControllerHeader()
141 141
142 142 self.m_ProcessingHeader = ProcessingHeader()
143 143
144 144 self.__fp = None
145 145
146 146 self.__idFile = None
147 147
148 148 self.__startDateTime = None
149 149
150 150 self.__endDateTime = None
151 151
152 152 self.__dataType = None
153 153
154 154 self.__fileSizeByHeader = 0
155 155
156 156 self.__pathList = []
157 157
158 158 self.filenameList = []
159 159
160 160 self.__lastUTTime = 0
161 161
162 162 self.__maxTimeStep = 30
163 163
164 164 self.__flagIsNewFile = 0
165 165
166 166 self.__ippSeconds = 0
167 167
168 168 self.flagResetProcessing = 0
169 169
170 170 self.flagIsNewBlock = 0
171 171
172 172 self.noMoreFiles = 0
173 173
174 174 self.nReadBlocks = 0
175 175
176 176 self.online = 0
177 177
178 178 self.filename = None
179 179
180 180 self.fileSize = None
181 181
182 182 self.firstHeaderSize = 0
183 183
184 184 self.basicHeaderSize = 24
185 185
186 186 self.idProfile = 0
187 187
188 188 self.datablock = None
189 189
190 self.datablock_id = 9999
190 self.__datablockIndex = 9999
191 191
192 192 def __rdSystemHeader(self,fp=None):
193 193 if fp == None:
194 194 fp = self.__fp
195 195
196 196 self.m_SystemHeader.read(fp)
197 197
198 198 def __rdRadarControllerHeader(self,fp=None):
199 199 if fp == None:
200 200 fp = self.__fp
201 201
202 202 self.m_RadarControllerHeader.read(fp)
203 203
204 204 def __rdProcessingHeader(self,fp=None):
205 205 if fp == None:
206 206 fp = self.__fp
207 207
208 208 self.m_ProcessingHeader.read(fp)
209 209
210 210 def __rdBasicHeader(self, fp=None):
211 211
212 212 if fp == None:
213 213 fp = self.__fp
214 214
215 215 self.m_BasicHeader.read(fp)
216 216
217 217 def __readFirstHeader(self):
218 218
219 219 self.__rdBasicHeader()
220 220 self.__rdSystemHeader()
221 221 self.__rdRadarControllerHeader()
222 222 self.__rdProcessingHeader()
223 223 self.firstHeaderSize = self.m_BasicHeader.size
224 224
225 225 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
226 226 if data_type == 0:
227 227 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
228 228
229 229 elif data_type == 1:
230 230 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
231 231
232 232 elif data_type == 2:
233 233 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
234 234
235 235 elif data_type == 3:
236 236 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
237 237
238 238 elif data_type == 4:
239 239 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
240 240
241 241 elif data_type == 5:
242 242 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
243 243
244 244 else:
245 245 raise ValueError, 'Data type was not defined'
246 246
247 247 xi = self.m_ProcessingHeader.firstHeight
248 248 step = self.m_ProcessingHeader.deltaHeight
249 249 xf = xi + self.m_ProcessingHeader.numHeights*step
250 250
251 251 self.__heights = numpy.arange(xi, xf, step)
252 252 self.__dataType = tmp
253 253 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
254 254 self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/self.__c
255 255
256 256 def __setNextFileOnline(self):
257 257 return 0
258 258
259 259 def __setNextFileOffline(self):
260 260
261 261 idFile = self.__idFile
262 262 while(True):
263 263
264 264 idFile += 1
265 265
266 266 if not(idFile < len(self.filenameList)):
267 267 self.noMoreFiles = 1
268 268 return 0
269 269
270 270 filename = self.filenameList[idFile]
271 271 fileSize = os.path.getsize(filename)
272 272
273 273 try:
274 274 fp = open(filename,'rb')
275 275 except:
276 276 raise IOError, "The file %s can't be opened" %filename
277 277
278 278 currentSize = fileSize - fp.tell()
279 279 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
280 280
281 281 if (currentSize < neededSize):
282 282 print "Skipping the file %s due to it hasn't enough data" %filename
283 283 continue
284 284
285 285 break
286 286
287 287 self.__flagIsNewFile = 1
288 288 self.__idFile = idFile
289 289 self.filename = filename
290 290 self.fileSize = fileSize
291 291 self.__fp = fp
292 292
293 293 print 'Setting the file: %s'%self.filename
294 294
295 295 return 1
296 296
297 297 def __setNextFile(self):
298 298
299 299 if self.online:
300 300 newFile = self.__setNextFileOnline()
301 301 else:
302 302 newFile = self.__setNextFileOffline()
303 303
304 304 if not(newFile):
305 305 return 0
306 306
307 307 self.__readFirstHeader()
308 308
309 309 return 1
310 310
311 311 def __setNewBlock(self):
312 312
313 313 if self.__fp == None:
314 314 return 0
315 315
316 316 if self.__flagIsNewFile:
317 317 return 1
318 318
319 319 currentSize = self.fileSize - self.__fp.tell()
320 320 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
321 321
322 322 #If there is enough data setting new data block
323 323 if (currentSize >= neededSize):
324 324 self.__rdBasicHeader()
325 325 return 1
326 326
327 327 #Setting new file
328 328 if not(self.__setNextFile()):
329 329 return 0
330 330
331 331 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
332 332
333 333 self.flagResetProcessing = 0
334 334
335 335 if deltaTime > self.__maxTimeStep:
336 336 self.flagResetProcessing = 1
337 337 self.nReadBlocks = 0
338 338
339 339 return 1
340 340
341 341 def __readBlock(self):
342 342 """
343 343 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
344 344 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
345 345 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
346 346 es seteado a 0
347 347
348 348
349 349 Inputs:
350 350 None
351 351
352 352 Return:
353 353 None
354 354
355 355 Variables afectadas:
356 356
357 self.datablock_id
357 self.__datablockIndex
358 358
359 359 self.datablock
360 360
361 361 self.__flagIsNewFile
362 362
363 363 self.idProfile
364 364
365 365 self.flagIsNewBlock
366 366
367 367 self.nReadBlocks
368 368
369 369 """
370 370
371 371 pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
372 372
373 373 junk = numpy.fromfile(self.__fp, self.__dataType, pts2read)
374 374
375 375 junk = junk.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels))
376 376
377 377 data = junk['real'] + junk['imag']*1j
378 378
379 self.datablock_id = 0
379 self.__datablockIndex = 0
380 380
381 381 self.datablock = data
382 382
383 383 self.__flagIsNewFile = 0
384 384
385 385 self.idProfile = 0
386 386
387 387 self.flagIsNewBlock = 1
388 388
389 389 self.nReadBlocks += 1
390 390
391 391 def __hasNotDataInBuffer(self):
392 if self.datablock_id >= self.m_ProcessingHeader.profilesPerBlock:
392 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
393 393 return 1
394 394
395 395 return 0
396 396
397 397 def __searchFiles(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
398 398 """
399 399 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
400 400 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
401 401 correcta la estructura de directorios debe ser la siguiente:
402 402
403 403 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
404 404
405 405 [yyyy]: anio
406 406 [ddd] : dia del anio
407 407 [sss] : set del archivo
408 408
409 409 Inputs:
410 410 path : Directorio de datos donde se realizara la busqueda. Todos los
411 411 ficheros que concidan con el criterio de busqueda seran
412 412 almacenados en una lista y luego retornados.
413 413 startDateTime : Fecha inicial. Rechaza todos los archivos donde
414 414 file end time < startDateTime (obejto datetime.datetime)
415 415
416 416 endDateTime : Fecha final. Rechaza todos los archivos donde
417 417 file start time > endDateTime (obejto datetime.datetime)
418 418
419 419 set : Set del primer archivo a leer. Por defecto None
420 420
421 421 expLabel : Nombre del subdirectorio de datos. Por defecto ""
422 422
423 423 ext : Extension de los archivos a leer. Por defecto .r
424 424
425 425 Return:
426 426
427 427 (pathList, filenameList)
428 428
429 429 pathList : Lista de directorios donde se encontraron archivos dentro
430 430 de los parametros especificados
431 431 filenameList : Lista de archivos (ruta completa) que coincidieron con los
432 432 parametros especificados.
433 433
434 434 Variables afectadas:
435 435
436 436 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
437 437 como fuente para leer los bloque de datos, si se termina
438 438 de leer todos los bloques de datos de un determinado
439 439 archivo se pasa al siguiente archivo de la lista.
440 440
441 441 Excepciones:
442 442
443 443 """
444 444
445 445 print "Searching files ..."
446 446
447 447 dirList = []
448 448 for thisPath in os.listdir(path):
449 449 if os.path.isdir(os.path.join(path,thisPath)):
450 450 dirList.append(thisPath)
451 451
452 452 pathList = []
453 453
454 454 thisDateTime = startDateTime
455 455
456 456 while(thisDateTime <= endDateTime):
457 457 year = thisDateTime.timetuple().tm_year
458 458 doy = thisDateTime.timetuple().tm_yday
459 459
460 460 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
461 461 if len(match) == 0:
462 462 thisDateTime += datetime.timedelta(1)
463 463 continue
464 464
465 465 pathList.append(os.path.join(path,match[0],expLabel))
466 466 thisDateTime += datetime.timedelta(1)
467 467
468 468 startUtSeconds = time.mktime(startDateTime.timetuple())
469 469 endUtSeconds = time.mktime(endDateTime.timetuple())
470 470
471 471 filenameList = []
472 472 for thisPath in pathList:
473 473 fileList = glob.glob1(thisPath, "*%s" %ext)
474 474 fileList.sort()
475 475 for file in fileList:
476 476 filename = os.path.join(thisPath,file)
477 477 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
478 478 filenameList.append(filename)
479 479
480 480 self.filenameList = filenameList
481 481
482 482 return pathList, filenameList
483 483
484 484 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0):
485 485 """
486 486 setup configura los parametros de lectura de la clase VoltageReader.
487 487
488 488 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
489 489 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
490 490 self.filenameList.
491 491
492 492 Input:
493 493 path : Directorios donde se ubican los datos a leer. Dentro de este
494 494 directorio deberia de estar subdirectorios de la forma:
495 495
496 496 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
497 497
498 498 startDateTime : Fecha inicial. Rechaza todos los archivos donde
499 499 file end time < startDatetime (obejto datetime.datetime)
500 500
501 501 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
502 502 file end time < startDatetime (obejto datetime.datetime)
503 503
504 504 set : Set del primer archivo a leer. Por defecto None
505 505
506 506 expLabel : Nombre del subdirectorio de datos. Por defecto ""
507 507
508 508 ext : Extension de los archivos a leer. Por defecto .r
509 509
510 510 online :
511 511
512 512 Return:
513 513
514 514 Affected:
515 515
516 516 Excepciones:
517 517
518 518 Example:
519 519
520 520 """
521 521
522 522 if online == 0:
523 523 pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext)
524 524
525 525 self.__idFile = -1
526 526
527 527 if not(self.__setNextFile()):
528 528 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
529 529 return 0
530 530
531 531 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
532 532 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
533 533
534 534 self.startYear = startDateTime.timetuple().tm_year
535 535 self.endYear = endDateTime.timetuple().tm_year
536
537 536 self.startDoy = startDateTime.timetuple().tm_yday
538 537 self.endDoy = endDateTime.timetuple().tm_yday
539 538
540 539 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
541 540 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
542 541 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
543 542 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
544 543 self.m_Voltage.dataType = self.__dataType
545 544
546 545 self.__pathList = pathList
547 546 self.filenameList = filenameList
548 547 self.online = online
549 548
550 549 return 1
551 550
552 551 def readNextBlock(self):
553 552 """
554 553 readNextBlock establece un nuevo bloque de datos a leer y los lee, si es que no existiese
555 554 mas bloques disponibles en el archivo actual salta al siguiente.
556 555
557 556 """
558 557
559 558 if not(self.__setNewBlock()):
560 559 return 0
561 560
562 561 self.__readBlock()
563 562
564 563 self.__lastUTTime = self.m_BasicHeader.utc
565 564
566 565 return 1
567 566
568 567 def getData(self):
569 568 """
570 569 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
571 570 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
572 571 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
573 572
574 573 Ademas incrementa el contador del buffer en 1.
575 574
576 575 Inputs:
577 576 None
578 577
579 578 Return:
580 579 data : retorna un perfil de voltages (alturas * canales) copiados desde el
581 580 buffer. Si no hay mas archivos a leer retorna None.
582 581
583 582 Variables afectadas:
584 583 self.m_Voltage
585 self.datablock_id
584 self.__datablockIndex
586 585 self.idProfile
587 586
588 587 Excepciones:
589 588
590 589 """
591 590 self.flagResetProcessing = 0
592 591 self.flagIsNewBlock = 0
593 592
594 593 if self.__hasNotDataInBuffer():
595 594 self.readNextBlock()
596 595
597 596 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
598 597 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
599 598 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
600 599 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
601 600
602 601 self.m_Voltage.heights = self.__heights
603 602 self.m_Voltage.dataType = self.__dataType
604 603
605 604 if self.noMoreFiles == 1:
606 605 print 'Process finished'
607 606 return None
608 607
609 608 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
610 609
611 time = self.m_BasicHeader.utc + self.datablock_id*self.__ippSeconds
610 time = self.m_BasicHeader.utc + self.__datablockIndex*self.__ippSeconds
612 611 self.m_Voltage.m_BasicHeader.utc = time
613 self.m_Voltage.data = self.datablock[self.datablock_id,:,:]
614 612 self.m_Voltage.flagNoData = False
615 613 self.m_Voltage.flagResetProcessing = self.flagResetProcessing
616 614
615 self.m_Voltage.data = self.datablock[self.__datablockIndex,:,:]
617 616 self.m_Voltage.idProfile = self.idProfile
618 617
619 618
620 self.datablock_id += 1
619 self.__datablockIndex += 1
621 620 self.idProfile += 1
622 621
623 622 #call setData - to Data Object
624 623
625 624 return self.m_Voltage.data
626 625
627 626 class VoltageWriter(DataWriter):
628 627 __configHeaderFile = 'wrSetHeadet.txt'
629 628
630 629 def __init__(self, m_Voltage = None):
631 630
632 631 if m_Voltage == None:
633 632 m_Voltage = Voltage()
634 633
635 634 self.m_Voltage = m_Voltage
636 635
637 636 self.__path = None
638 637
639 638 self.__fp = None
640 639
641 640 self.__format = None
642 641
643 642 self.__blocksCounter = 0
644 643
645 644 self.__setFile = None
646 645
647 646 self.__flagIsNewFile = 1
648 647
649 648 self.datablock = None
650 649
651 self.datablock_id = 0
650 self.__datablockIndex = 0
652 651
653 652 self.__dataType = None
654 653
655 654 self.__ext = None
656 655
657 656 self.__shapeBuffer = None
658 657
659 658 self.nWriteBlocks = 0
660 659
661 660 self.flagIsNewBlock = 0
662 661
663 662 self.noMoreFiles = 0
664 663
665 664 self.filename = None
666 665
667 666 self.m_BasicHeader= BasicHeader()
668 667
669 668 self.m_SystemHeader = SystemHeader()
670 669
671 670 self.m_RadarControllerHeader = RadarControllerHeader()
672 671
673 672 self.m_ProcessingHeader = ProcessingHeader()
674 673
675 674
675 def __writeFirstHeader(self):
676 self.__writeBasicHeader()
677 self.__wrSystemHeader()
678 self.__wrRadarControllerHeader()
679 self.__wrProcessingHeader()
680 self.__dataType = self.m_Voltage.dataType
681
676 682 def __writeBasicHeader(self, fp=None):
677 683 if fp == None:
678 684 fp = self.__fp
679 685
680 686 self.m_BasicHeader.write(fp)
681 687
682 688 def __wrSystemHeader(self,fp=None):
683 689 if fp == None:
684 690 fp = self.__fp
685 691
686 692 self.m_SystemHeader.write(fp)
687 693
688 694 def __wrRadarControllerHeader(self,fp=None):
689 695 if fp == None:
690 696 fp = self.__fp
691 697
692 698 self.m_RadarControllerHeader.write(fp)
693 699
694 700 def __wrProcessingHeader(self,fp=None):
695 701 if fp == None:
696 702 fp = self.__fp
697 703
698 704 self.m_ProcessingHeader.write(fp)
699 705
700 def __writeFirstHeader(self):
701 self.__writeBasicHeader()
702 self.__wrSystemHeader()
703 self.__wrRadarControllerHeader()
704 self.__wrProcessingHeader()
705 self.__dataType = self.m_Voltage.dataType
706
707
708 706 def __setNextFile(self):
709 707
710 708 setFile = self.__setFile
711 709 ext = self.__ext
712 710 path = self.__path
713 711
714 712 setFile += 1
715 713
716 714 if self.__fp != None:
717 715 self.__fp.close()
718 716
719 717 timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
720 718 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext)
721 719 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
722 720 tmp = os.path.join(path,subfolder)
723 721 if not(os.path.exists(tmp)):
724 722 os.mkdir(tmp)
725 723
726 724 filename = os.path.join(path,subfolder,file)
727 725 fp = open(filename,'wb')
728 726
729 727 self.__blocksCounter = 0
730 728
731 729 #guardando atributos
732 730 self.filename = filename
733 731 self.__subfolder = subfolder
734 732 self.__fp = fp
735 733 self.__setFile = setFile
736 734 self.__flagIsNewFile = 1
737 735
738 736 print 'Writing the file: %s'%self.filename
739 737
740 738 self.__writeFirstHeader()
741 739
742 740 return 1
743 741
744 742 def __setNewBlock(self):
745 743
746 744 if self.__fp == None:
747 745 self.__setNextFile()
748 746
749 747 if self.__flagIsNewFile:
750 748 return 1
751 749
752 750 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
753 751 self.__writeBasicHeader()
754 752 return 1
755 753
756 754 if not(self.__setNextFile()):
757 755 return 0
758 756
759 757 return 1
760 758
761 759 def __writeBlock(self):
762 760
763 761 data = numpy.zeros(self.__shapeBuffer, self.__dataType)
764 762
765 763 data['real'] = self.datablock.real
766 764 data['imag'] = self.datablock.imag
767 765
768 766 data = data.reshape((-1))
769 767
770 768 data.tofile(self.__fp)
771 769
772 770 self.datablock.fill(0)
773 771
774 self.datablock_id = 0
772 self.__datablockIndex = 0
775 773
776 774 self.__flagIsNewFile = 0
777 775
778 776 self.flagIsNewBlock = 1
779 777
780 778 self.nWriteBlocks += 1
781 779
782 780 self.__blocksCounter += 1
783 781
784 782
785 783 def writeNextBlock(self):
786 784
787 785 if not(self.__setNewBlock()):
788 786 return 0
789 787
790 788 self.__writeBlock()
791 789
792 790 return 1
793 791
794 792 def __hasAllDataInBuffer(self):
795 if self.datablock_id >= self.m_ProcessingHeader.profilesPerBlock:
793 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
796 794 return 1
797 795
798 796 return 0
799 797
800 798 def putData(self):
801 799
802 800 self.flagIsNewBlock = 0
803 801
804 802 if self.m_Voltage.flagNoData:
805 803 return 0
806 804
807 805 if self.m_Voltage.flagResetProcessing:
808 806
809 807 self.datablock.fill(0)
810 808
811 self.datablock_id = 0
809 self.__datablockIndex = 0
812 810 self.__setNextFile()
813 811
814 self.datablock[self.datablock_id,:,:] = self.m_Voltage.data
812 self.datablock[self.__datablockIndex,:,:] = self.m_Voltage.data
815 813
816 self.datablock_id += 1
814 self.__datablockIndex += 1
817 815
818 816 if self.__hasAllDataInBuffer():
819 817
820 818 self.__getHeader()
821 819 self.writeNextBlock()
822 820
823 821 if self.noMoreFiles:
824 822 #print 'Process finished'
825 823 return 0
826 824
827 825 return 1
828 826
829 827 def __getHeader(self):
830 828 self.m_BasicHeader = self.m_Voltage.m_BasicHeader.copy()
831 829 self.m_SystemHeader = self.m_Voltage.m_SystemHeader.copy()
832 830 self.m_RadarControllerHeader = self.m_Voltage.m_RadarControllerHeader.copy()
833 831 self.m_ProcessingHeader = self.m_Voltage.m_ProcessingHeader.copy()
834 832 self.__dataType = self.m_Voltage.dataType
835 833
836 834 def __setHeaderByFile(self):
837 835
838 836 format = self.__format
839 837 header = ['Basic','System','RadarController','Processing']
840 838
841 839 fmtFromFile = None
842 840 headerFromFile = None
843 841
844 842
845 843 fileTable = self.__configHeaderFile
846 844
847 845 if os.access(fileTable, os.R_OK):
848 846 import re, string
849 847
850 848 f = open(fileTable,'r')
851 849 lines = f.read()
852 850 f.close()
853 851
854 852 #Delete comments into expConfig
855 853 while 1:
856 854
857 855 startComment = string.find(lines.lower(),'#')
858 856 if startComment == -1:
859 857 break
860 858 endComment = string.find(lines.lower(),'\n',startComment)
861 859 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
862 860
863 861 while expFromFile == None:
864 862
865 863 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
866 864 nextFmt = string.find(lines.lower(),'format',currFmt+10)
867 865
868 866 if currFmt == -1:
869 867 break
870 868 if nextFmt == -1:
871 869 nextFmt = len(lines)-1
872 870
873 871 fmtTable = lines[currFmt:nextFmt]
874 872 lines = lines[nextFmt:]
875 873
876 874 fmtRead = self.__getValueFromArg(fmtTable,'format')
877 875 if fmtRead != format:
878 876 continue
879 877 fmtFromFile = fmtRead
880 878
881 879 lines2 = fmtTable
882 880
883 881 while headerFromFile == None:
884 882
885 883 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
886 884 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
887 885
888 886 if currHeader == -1:
889 887 break
890 888 if nextHeader == -1:
891 889 nextHeader = len(lines2)-1
892 890
893 891 headerTable = lines2[currHeader:nextHeader]
894 892 lines2 = lines2[nextHeader:]
895 893
896 894 headerRead = self.__getValueFromArg(headerTable,'site')
897 895 if not(headerRead in header):
898 896 continue
899 897 headerFromFile = headerRead
900 898
901 899 if headerRead == 'Basic':
902 900 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
903 901 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
904 902 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
905 903 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
906 904 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
907 905 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
908 906 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
909 907 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
910 908
911 909 else:
912 910 print "file access denied:%s"%fileTable
913 911 sys.exit(0)
914 912
915 913 def setup(self, path, set=0, format='rawdata'):
916 914
917 915
918 916 if format == 'hdf5':
919 917 ext = '.hdf5'
920 918 format = 'hdf5'
921 919 print 'call hdf5 library'
922 920 return 0
923 921
924 922 if format == 'rawdata':
925 923 ext = '.r'
926 924 format = 'Jicamarca'
927 925
928 926 #call to config_headers
929 927 #self.__setHeaderByFile()
930 928
931 929 self.__path = path
932 930 self.__setFile = set - 1
933 931 self.__ext = ext
934 932 self.__format = format
935 933
936 934 self.__getHeader()
937 935 self.__shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
938 936 self.m_ProcessingHeader.numHeights,
939 937 self.m_SystemHeader.numChannels )
940 938
941 939 self.datablock = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex'))
942 940
943 941 # if not(self.__setNextFile()):
944 942 # return 0
945 943 return 1
946 944
947 945
948 946
949 947
950 948 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now