##// END OF EJS Templates
schain-jc
RSS
Miguel Valdez -
r49:6f5fecf4762e
parent child
Show More
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (1507 lines changed) Show them Hide them
@@ -1,19 +1,1514
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 import os, sys
8 import glob
9 import time
10 import numpy
7
11
12 path = os.path.split(os.getcwd())[0]
13 sys.path.append(path)
8
14
9 class DataReader:
15 from Model.JROHeader import *
16
17 def checkForRealPath( path, year, doy, set, ext ):
18 """
19 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
20 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
21 el path exacto de un determinado file.
22
23 Example :
24 nombre correcto del file es ../RAWDATA/D2009307/P2009307367
25
26 Entonces la funcion prueba con las siguientes combinaciones
27 ../RAWDATA/d2009307/p2009307367
28 ../RAWDATA/d2009307/P2009307367
29 ../RAWDATA/D2009307/p2009307367
30 ../RAWDATA/D2009307/P2009307367
31 siendo para este caso, la ultima combinacion de letras, identica al file buscado
32
33 Return:
34 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
35 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
36 para el filename
37 """
38 filepath = None
39 find_flag = False
40 filename = None
41
42 for dir in "dD": #barrido por las dos combinaciones posibles de "D"
43 for fil in "dD": #barrido por las dos combinaciones posibles de "D"
44 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
45 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext (p=d o p=D)
46 filepath = os.path.join( path, doypath, filename ) #formo el path completo
47 if os.path.exists( filepath ): #verifico que exista
48 find_flag = True
49 break
50 if find_flag:
51 break
52
53 if not(find_flag):
54 return None, filename
55
56 return filepath, filename
57
58
59 def isNumber( str ):
60 """
61 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
62
63 Excepciones:
64 Si un determinado string no puede ser convertido a numero
65 Input:
66 str, string al cual se le analiza para determinar si convertible a un numero o no
67
68 Return:
69 True : si el string es uno numerico
70 False : no es un string numerico
71 """
72 try:
73 float( str )
74 return True
75 except:
76 return False
77
78
79 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
80 """
81 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
82 o no dentro del rango de fecha especificado.
83
84 Inputs:
85 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
86
87 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
88 segundos contados desde 01/01/1970.
89 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
90 segundos contados desde 01/01/1970.
91
92 Return:
93 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
94 fecha especificado, de lo contrario retorna False.
95
96 Excepciones:
97 Si el archivo no existe o no puede ser abierto
98 Si la cabecera no puede ser leida.
99
100 """
101 m_BasicHeader = BasicHeader()
102
103 try:
104 fp = open(filename,'rb')
105 except:
106 raise IOError, "The file %s can't be opened" %(filename)
107
108 if not(m_BasicHeader.read(fp)):
109 raise IOError, "The file %s has not a valid header" %(filename)
110
111 fp.close()
112
113 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
114 return 0
115
116 return 1
117
118
119 def getlastFileFromPath( pathList, ext ):
120 """
121 Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
122 al final de la depuracion devuelve el ultimo file de la lista que quedo.
123
124 Input:
125 pathList : lista conteniendo todos los filename completos que componen una determinada carpeta
126 ext : extension de los files contenidos en una carpeta
127
128 Return:
129 El ultimo file de una determinada carpeta
130 """
131
132 filesList = []
133 filename = None
134
135 # 0 1234 567 89A BCDE
136 # D YYYY DDD SSS .ext
137
138 for filename in pathList:
139 year = filename[1:5]
140 doy = filename[5:8]
141 leng = len( ext )
142
143 if ( filename[-leng:].upper() != ext.upper() ) : continue
144 if not( isNumber( year ) ) : continue
145 if not( isNumber( doy ) ) : continue
146
147 filesList.append(filename)
148
149 if len( filesList ) > 0:
150 filesList = sorted( filesList, key=str.lower )
151 filename = filesList[-1]
152
153 return filename
154
155
156 class DataReader():
10
157
11 def __init__(self):
158 def __init__(self):
12 __buffer = 0
159 pass
13 __buffer_count = 0
160
161 class DataWriter():
162
163 def __init__(self):
164 pass
165
166 class JRODataReader():
167
168 """
169 Esta clase es usada como la clase padre de las clases VoltageReader and SpectraReader,
170 contiene todos lo metodos necesarios para leer datos desde archivos en formato
171 Jicamarca (.r o .pdata). La lectura de los datos siempre se realiza por bloques. Los datos
172 leidos son array de 3 dimensiones:
173 perfiles*alturas*canales
174
175 y son almacenados en la variable "datablock".
176
177 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
178 RadarControllerHeader y DataObj. Los tres primeros se usan para almacenar informacion de la
179 cabecera de datos (metadata), y el cuarto (DataObj) para obtener y almacenar los datos desde
180 el "datablock" cada vez que se ejecute el metodo "getData".
181
182
183 """
184
185 m_BasicHeader = BasicHeader()
186
187 m_SystemHeader = SystemHeader()
188
189 m_RadarControllerHeader = RadarControllerHeader()
190
191 m_ProcessingHeader = ProcessingHeader()
192
193 m_DataObj = None
194
195 online = 0
196
197 __startDateTime = None
198
199 __endDateTime = None
200
201 __fp = None
202
203 __fileSizeByHeader = None
204
205 __pathList = []
206
207 __filenameList = []
208
209 __fileIndex = None
210
211 filename = None
212
213 fileSize = None
214
215 firstHeaderSize = 0
216
217 basicHeaderSize = 24
218
219 __dataType = None
220
221 __blocksize = 0
222
223 datablock = None
224
225 __datablockIndex = None
226
227 __pts2read = 0
228
229 #Parametros para el procesamiento en linea
230 __year = 0
231
232 __doy = 0
233
234 __set = 0
235
236 __ext = None
237
238 __path = None
239
240 __delay = 60 #seconds
241
242 __nTries = 3 #quantity tries
243
244 __nFiles = 3 #number of files for searching
245
246 #speed of light
247 __c = 3E8
248
249 def __init__(self):
250
251 """
252 Inicializador
253 """
254
255 raise ValueError, "This class has not been implemented"
256
257 def __rdSystemHeader(self,fp=None):
258
259 if fp == None:
260 fp = self.__fp
261
262 self.m_SystemHeader.read(fp)
263
264 def __rdRadarControllerHeader(self,fp=None):
265 if fp == None:
266 fp = self.__fp
267
268 self.m_RadarControllerHeader.read(fp)
269
270 def __rdProcessingHeader(self,fp=None):
271 if fp == None:
272 fp = self.__fp
273
274 self.m_ProcessingHeader.read(fp)
275
276 def __rdBasicHeader(self, fp=None):
277
278 if fp == None:
279 fp = self.__fp
280
281 self.m_BasicHeader.read(fp)
282
283 def __readFirstHeader(self):
284
285 self.__rdBasicHeader()
286 self.__rdSystemHeader()
287 self.__rdRadarControllerHeader()
288 self.__rdProcessingHeader()
289 self.firstHeaderSize = self.m_BasicHeader.size
290
291 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
292 if data_type == 0:
293 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
294
295 elif data_type == 1:
296 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
297
298 elif data_type == 2:
299 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
300
301 elif data_type == 3:
302 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
303
304 elif data_type == 4:
305 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
306
307 elif data_type == 5:
308 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
309
310 else:
311 raise ValueError, 'Data type was not defined'
312
313 xi = self.m_ProcessingHeader.firstHeight
314 step = self.m_ProcessingHeader.deltaHeight
315 xf = xi + self.m_ProcessingHeader.numHeights*step
316
317 self.__heights = numpy.arange(xi, xf, step)
318 self.__dataType = tmp
319 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
320 self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/self.__c
321
322 self.__pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
323 self.__blocksize = self.__pts2read
324
325
326 def __setNextFileOnline( self ):
327 """
328 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
329 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
330 siguientes.
331
332 Affected:
333 self.__flagNewFile
334 self.filename
335 self.fileSize
336 self.__fp
337 self.__set
338 self.flagNoMoreFiles
339
340 Return:
341 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
342 1 : si el file fue abierto con exito y esta listo a ser leido
343
344 Excepciones:
345 Si un determinado file no puede ser abierto
346 """
347 countFiles = 0
348 countTries = 0
349
350 fileStatus = 0
351 notFirstTime_flag = False
352 bChangeDir = False
353
354 fileSize = 0
355 fp = None
356
357 self.__flagNewFile = 0
358
359 #este loop permite llevar la cuenta de intentos, de files y carpetas, si no encuentra alguno sale del bucle
360 while( True ):
361 countFiles += 1
362
363 if countFiles > (self.__nFiles + 1):
364 break
365
366 self.__set += 1
367
368 if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
369 self.__set = 0
370 self.__doy += 1
371 bChangeDir = True
372
373 file = None
374 filename = None
375
376 countTries = 0
377
378 #espero hasta encontrar el 1er file disponible
379 while( True ):
380
381 countTries += 1
382 if( countTries >= self.__nTries ): #checkeo que no haya ido mas alla de la cantidad de intentos
383 break
384
385 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
386 if file != None:
387 break
388
389 if notFirstTime_flag: #este flag me sirve solo para esperar por el 1er file, en lo siguientes no espera solo checkea si existe o no
390 countTries = self.__nTries
391 print "\tsearching next \"%s\" file ..." % filename
392 break
393
394 print "\twaiting new \"%s\" file ..." % filename
395 time.sleep( self.__delay )
396
397 if countTries >= self.__nTries: #se realizaron n intentos y no hubo un file nuevo
398 notFirstTime_flag = True
399 continue #vuelvo al inico del while principal
400
401 countTries = 0
402
403 #una vez que se obtuvo el 1er file valido se procede a checkear su contenido, y se espera una cierta cantidad
404 #de tiempo por una cierta cantidad de veces hasta que el contenido del file sea un contenido valido
405 while( True ):
406 countTries += 1
407 if countTries > self.__nTries:
408 break
409
410 try:
411 fp = open(file)
412 except:
413 print "The file \"%s\" can't be opened" % file
414 break
415
416 fileSize = os.path.getsize( file )
417 currentSize = fileSize - fp.tell()
418 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
419
420 if currentSize > neededSize:
421 fileStatus = 1
422 break
423
424 fp.close()
425
426 if bChangeDir: #si al buscar un file cambie de directorio ya no espero y salgo del bucle while
427 print "\tsearching next \"%s\" file ..." % filename
428 break
429
430 print "\twaiting for block of \"%s\" file ..." % filename
431 time.sleep( self.__delay )
432
433 if fileStatus == 1:
434 break
435
436 print "Skipping the file \"%s\" due to this files is empty" % filename
437 countFiles = 0
438
439
440 if fileStatus == 1:
441 self.fileSize = fileSize
442 self.filename = file
443 self.__flagNewFile = 1
444 self.__fp = fp
445 self.flagNoMoreFiles = 0
446 print 'Setting the file: %s' % file
447 else:
448 self.fileSize = 0
449 self.filename = None
450 self.__fp = None
451 self.flagNoMoreFiles = 1
452 print 'No more Files'
453
454 return fileStatus
455
456
457 def __setNextFileOffline(self):
458
459 idFile = self.__fileIndex
460 while(True):
461
462 idFile += 1
463
464 if not(idFile < len(self.__filenameList)):
465 self.flagNoMoreFiles = 1
466 return 0
467
468 filename = self.__filenameList[idFile]
469 fileSize = os.path.getsize(filename)
470
471 try:
472 fp = open(filename,'rb')
473 except:
474 raise IOError, "The file %s can't be opened" %filename
475
476 currentSize = fileSize - fp.tell()
477 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
478
479 if (currentSize < neededSize):
480 print "Skipping the file %s due to it hasn't enough data" %filename
481 continue
482
483 break
484
485 self.__flagNewFile = 1
486 self.__fileIndex = idFile
487 self.filename = filename
488 self.fileSize = fileSize
489 self.__fp = fp
490
491 print 'Setting the file: %s'%self.filename
492
493 return 1
494
495 def __setNextFile( self ):
496 """
497 Determina el siguiente file a leer y si hay uno disponible lee el First Header
498
499 Affected:
500 self.m_BasicHeader
501 self.m_SystemHeader
502 self.m_RadarControllerHeader
503 self.m_ProcessingHeader
504 self.firstHeaderSize
505
506 Return:
507 0 : Si no hay files disponibles
508 1 : Si hay mas files disponibles
509 """
510 if self.__fp != None:
511 self.__fp.close()
512
513 if self.online:
514 newFile = self.__setNextFileOnline()
515 else:
516 newFile = self.__setNextFileOffline()
517
518 if not(newFile):
519 return 0
520
521 self.__readFirstHeader()
522
523 return 1
524
525
526 def __setNewBlock( self ):
527 """
528 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
529
530 Affected:
531 self.m_BasicHeader
532 self.flagNoContinuousBlock
533 self.ns
534
535 Return:
536 0 : Si el file no tiene un Basic Header que pueda ser leido
537 1 : Si se pudo leer el Basic Header
538 """
539 if self.__fp == None:
540 return 0
541
542 if self.__flagNewFile:
543 return 1
544
545 currentSize = self.fileSize - self.__fp.tell()
546 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
547
548 #If there is enough data setting new data block
549 if ( currentSize >= neededSize ):
550 self.__rdBasicHeader()
551 return 1
552 elif self.online:
553 nTries = 0
554 while( nTries < self.__nTries ):
555 nTries += 1
556 print "Waiting for the next block, try %03d ..." % nTries
557 time.sleep( self.__delay )
558
559 fileSize = os.path.getsize(self.filename)
560 currentSize = fileSize - self.__fp.tell()
561 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
562
563 if ( currentSize >= neededSize ):
564 self.__rdBasicHeader()
565 return 1
566
567 #Setting new file
568 if not( self.__setNextFile() ):
569 return 0
570
571 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
572
573 self.flagNoContinuousBlock = 0
574
575 if deltaTime > self.__maxTimeStep:
576 self.flagNoContinuousBlock = 1
577 self.nReadBlocks = 0
578
579 return 1
580
581 def __readBlock(self):
582 """
583 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
584 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
585 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
586 es seteado a 0
587
588
589 Inputs:
590 None
591
592 Return:
593 None
594
595 Variables afectadas:
596
597 self.__datablockIndex
598
599 self.datablock
600
601 self.__flagNewFile
602
603 self.__flagNewBlock
604
605 self.nReadBlocks
606
607 """
608
609 #pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
610
611 fpointer = self.__fp.tell()
612
613 junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
614
615 if self.online:
616 if junk.size != self.__blocksize:
617 nTries = 0
618 while( nTries < self.__nTries ):
619 nTries += 1
620 print "Waiting for the next block, try %03d ..." % nTries
621 time.sleep( self.__delay )
622 self.__fp.seek( fpointer )
623 fpointer = self.__fp.tell()
624 junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
625 if junk.size == self.__blocksize:
626 nTries = 0
627 break
628 if nTries > 0:
629 return
630
631 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
632
633 data = junk['real'] + junk['imag']*1j
634
635 self.__datablockIndex = 0
636
637 self.datablock = data
638
639 self.__flagNewFile = 0
640
641 self.__flagNewBlock = 1
642
643 self.nReadBlocks += 1
644
645 def __hasNotDataInBuffer(self):
646 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
647 return 1
648
649 return 0
650
651
652 def __searchFilesOnLine( self, path, startDateTime=None, ext = ".r" ):
653 """
654 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
655 devuelve el archivo encontrado ademas de otros datos.
656
657 Input:
658 path : carpeta donde estan contenidos los files que contiene data
659 startDateTime : punto especifico en el tiempo del cual se requiere la data
660 ext : extension de los files
661
662 Return:
663 year : el anho
664 doy : el numero de dia del anho
665 set : el set del archivo
666 filename : el ultimo file de una determinada carpeta
667 directory : eL directorio donde esta el file encontrado
668 """
669
670 print "Searching files ..."
671
672 dirList = []
673 directory = None
674
675 if startDateTime == None:
676 for thisPath in os.listdir(path):
677 if os.path.isdir( os.path.join(path,thisPath) ):
678 dirList.append( thisPath )
679
680 dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted
681 if len(dirList) > 0 :
682 directory = dirList[-1]
683 else:
684 year = startDateTime.timetuple().tm_year
685 doy = startDateTime.timetuple().tm_yday
686
687 doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas
688 if os.path.isdir( os.path.join(path,doyPath) ):
689 directory = doyPath
690
691 doyPath = doyPath.lower() #caso del nombre en minusculas
692 if os.path.isdir( os.path.join(path,doyPath) ):
693 directory = doyPath
694
695 if directory == None:
696 return 0, 0, 0, None, None
697
698 filename = getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext )
699
700 if filename == None:
701 return 0, 0, 0, None, None
702
703 year = int( directory[-7:-3] )
704 doy = int( directory[-3:] )
705 ln = len( ext )
706 set = int( filename[-ln-3:-ln] )
707
708 return year, doy, set, filename, directory
709
710
711 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
712 """
713 Realiza una busqueda de los archivos que coincidan con los parametros
714 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
715 correcta la estructura de directorios debe ser la siguiente:
716
717 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
718
719 [yyyy]: anio
720 [ddd] : dia del anio
721 [sss] : set del archivo
722
723 Inputs:
724 path : Directorio de datos donde se realizara la busqueda. Todos los
725 ficheros que concidan con el criterio de busqueda seran
726 almacenados en una lista y luego retornados.
727 startDateTime : Fecha inicial. Rechaza todos los archivos donde
728 file end time < startDateTime (obejto datetime.datetime)
729
730 endDateTime : Fecha final. Rechaza todos los archivos donde
731 file start time > endDateTime (obejto datetime.datetime)
732
733 set : Set del primer archivo a leer. Por defecto None
734
735 expLabel : Nombre del subdirectorio de datos. Por defecto ""
736
737 ext : Extension de los archivos a leer. Por defecto .r
738
739 Return:
740
741 (pathList, filenameList)
742
743 pathList : Lista de directorios donde se encontraron archivos dentro
744 de los parametros especificados
745 filenameList : Lista de archivos (ruta completa) que coincidieron con los
746 parametros especificados.
747
748 Variables afectadas:
749
750 self.__filenameList: Lista de archivos (ruta completa) que la clase utiliza
751 como fuente para leer los bloque de datos, si se termina
752 de leer todos los bloques de datos de un determinado
753 archivo se pasa al siguiente archivo de la lista.
754
755 Excepciones:
756
757 """
758
759 print "Searching files ..."
760
761 dirList = []
762 for thisPath in os.listdir(path):
763 if os.path.isdir(os.path.join(path,thisPath)):
764 dirList.append(thisPath)
765
766 pathList = []
767
768 thisDateTime = startDateTime
769
770 while(thisDateTime <= endDateTime):
771 year = thisDateTime.timetuple().tm_year
772 doy = thisDateTime.timetuple().tm_yday
773
774 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
775 if len(match) == 0:
776 thisDateTime += datetime.timedelta(1)
777 continue
778
779 pathList.append(os.path.join(path,match[0],expLabel))
780 thisDateTime += datetime.timedelta(1)
781
782 startUtSeconds = time.mktime(startDateTime.timetuple())
783 endUtSeconds = time.mktime(endDateTime.timetuple())
784
785 filenameList = []
786 for thisPath in pathList:
787 fileList = glob.glob1(thisPath, "*%s" %ext)
788 fileList.sort()
789 for file in fileList:
790 filename = os.path.join(thisPath,file)
791 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
792 filenameList.append(filename)
793
794 self.__filenameList = filenameList
795
796 return pathList, filenameList
797
798
799 def __initFilesOnline( self, path, dirfilename, filename ):
800 """
801 Verifica que el primer file tenga una data valida, para ello leo el 1er bloque
802 del file, si no es un file valido espera una cierta cantidad de tiempo a que
803 lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo
804 devuelve 0 caso contrario devuelve 1
805
806 Affected:
807 m_BasicHeader
808
809 Return:
810 0 : file no valido para ser leido
811 1 : file valido para ser leido
812 """
813 m_BasicHeader = BasicHeader()
814
815 file = os.path.join( path, dirfilename, filename )
816
817 nTries = 0
818 while(True):
819
820 nTries += 1
821 if nTries > self.__nTries:
822 break
823
824 try:
825 fp = open( file,'rb' ) #lectura binaria
826 except:
827 raise IOError, "The file %s can't be opened" %(file)
828
829 try:
830 m_BasicHeader.read(fp)
831 except:
832 print "The file %s is empty" % filename
833
834 fp.close()
835
836 if m_BasicHeader.size > 24:
837 break
838
839 print 'waiting for new block: try %02d' % ( nTries )
840 time.sleep( self.__delay)
841
842 if m_BasicHeader.size <= 24:
843 return 0
844
845 return 1
846
847
848 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0):
849 """
850 setup configura los parametros de lectura de la clase VoltageReader.
851
852 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
853 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
854 self.__filenameList.
855
856 Input:
857 path : Directorios donde se ubican los datos a leer. Dentro de este
858 directorio deberia de estar subdirectorios de la forma:
859
860 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
861
862 startDateTime : Fecha inicial. Rechaza todos los archivos donde
863 file end time < startDatetime (obejto datetime.datetime)
864
865 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
866 file end time < startDatetime (obejto datetime.datetime)
867
868 set : Set del primer archivo a leer. Por defecto None
869
870 expLabel : Nombre del subdirectorio de datos. Por defecto ""
871
872 ext : Extension de los archivos a leer. Por defecto .r
873
874 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
875
876 Return:
877 0 : Si no encuentra files que cumplan con las condiciones dadas
878 1 : Si encuentra files que cumplan con las condiciones dadas
879
880 Affected:
881 self.startUTCSeconds
882 self.endUTCSeconds
883 self.startYear
884 self.endYear
885 self.startDoy
886 self.endDoy
887 self.__pathList
888 self.__filenameList
889 self.online
890 """
891 if online:
892 nTries = 0
893 while( nTries < self.__nTries ):
894 nTries += 1
895 subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
896 year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
897 if filename == None:
898 file = os.path.join( path, subfolder )
899 print "Searching first file in \"%s\", try %03d ..." % ( file, nTries )
900 time.sleep( self.__delay )
901 else:
902 break
903
904 if filename == None:
905 print "No files On Line"
906 return 0
907
908 if self.__initFilesOnline( path, dirfilename, filename ) == 0:
909 print "The file %s hasn't enough data"
910 return 0
911
912 self.__year = year
913 self.__doy = doy
914 self.__set = set - 1
915 self.__path = path
916
917 else:
918 pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext )
919 self.__fileIndex = -1
920 self.__pathList = pathList
921 self.__filenameList = filenameList
922
923 self.online = online
924 self.__ext = ext
925
926 if not( self.__setNextFile() ):
927 if (startDateTime != None) and (endDateTime != None):
928 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
929 elif startDateTime != None:
930 print "No files in : %s" % startDateTime.ctime()
931 else:
932 print "No files"
933 return 0
934
935 if startDateTime != None:
936 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
937 self.startYear = startDateTime.timetuple().tm_year
938 self.startDoy = startDateTime.timetuple().tm_yday
939
940 if endDateTime != None:
941 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
942 self.endYear = endDateTime.timetuple().tm_year
943 self.endDoy = endDateTime.timetuple().tm_yday
944 #call fillHeaderValues() - to Data Object
945
946 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
947 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
948 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
949 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
950 self.m_Voltage.dataType = self.__dataType
951
952 return 1
953
954
955 def readNextBlock( self ):
956 """
957 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
958 mas bloques disponibles en el archivo actual salta al siguiente.
959
960 Affected:
961 self.__lastUTTime
962
963 Return: None
964 """
965 if not(self.__setNewBlock()):
966 return 0
967
968 self.__readBlock()
969
970 self.__lastUTTime = self.m_BasicHeader.utc
971
972 return 1
973
974
975 def getData( self ):
976 """
977 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
978 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
979 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
980
981 Ademas incrementa el contador del buffer en 1.
982
983 Return:
984 data : retorna un perfil de voltages (alturas * canales) copiados desde el
985 buffer. Si no hay mas archivos a leer retorna None.
986
987 Variables afectadas:
988 self.m_Voltage
989 self.__datablockIndex
990
991 Affected:
992 self.m_Voltage
993 self.__datablockIndex
994 self.flagNoContinuousBlock
995 self.__flagNewBlock
996 """
997 self.flagNoContinuousBlock = 0
998 self.__flagNewBlock = 0
999
1000 if self.__hasNotDataInBuffer():
1001
1002 self.readNextBlock()
1003
1004 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
1005 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1006 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1007 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
1008 self.m_Voltage.heights = self.__heights
1009 self.m_Voltage.dataType = self.__dataType
1010
1011 if self.flagNoMoreFiles == 1:
1012 print 'Process finished'
1013 return None
1014
1015 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1016
1017 time = self.m_BasicHeader.utc + self.__datablockIndex * self.__ippSeconds
1018 self.m_Voltage.m_BasicHeader.utc = time
1019
1020 self.m_Voltage.flagNoData = False
1021 self.m_Voltage.flagNoContinuousBlock = self.flagNoContinuousBlock
1022
1023 self.m_Voltage.data = self.datablock[self.__datablockIndex,:,:]
1024 self.m_Voltage.profileIndex = self.__datablockIndex
1025
1026 self.__datablockIndex += 1
1027
1028 #call setData - to Data Object
1029
1030 return self.m_Voltage.data
1031
1032
1033 #class VoltageWriter(DataWriter):
1034 # """
1035 # Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
1036 # de los datos siempre se realiza por bloques.
1037 # """
1038 # __configHeaderFile = 'wrSetHeadet.txt'
1039 #
1040 # def __init__( self, m_Voltage = None ):
1041 # """
1042 # Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
1043 #
1044 # Affected:
1045 # self.m_Voltage
1046 # self.m_BasicHeader
1047 # self.m_SystemHeader
1048 # self.m_RadarControllerHeader
1049 # self.m_ProcessingHeader
1050 #
1051 # Return: None
1052 # """
1053 # if m_Voltage == None:
1054 # m_Voltage = Voltage()
1055 #
1056 # self.m_Voltage = m_Voltage
1057 #
1058 # self.__path = None
1059 #
1060 # self.__fp = None
1061 #
1062 # self.__format = None
1063 #
1064 # self.__blocksCounter = 0
1065 #
1066 # self.__setFile = None
1067 #
1068 # self.__flagNewFile = 1
1069 #
1070 # self.datablock = None
1071 #
1072 # self.__datablockIndex = 0
1073 #
1074 # self.__dataType = None
1075 #
1076 # self.__ext = None
1077 #
1078 # self.__shapeBuffer = None
1079 #
1080 # self.nWriteBlocks = 0
1081 #
1082 # self.__flagNewBlock = 0
1083 #
1084 # self.flagNoMoreFiles = 0
1085 #
1086 # self.filename = None
1087 #
1088 # self.m_BasicHeader= BasicHeader()
1089 #
1090 # self.m_SystemHeader = SystemHeader()
1091 #
1092 # self.m_RadarControllerHeader = RadarControllerHeader()
1093 #
1094 # self.m_ProcessingHeader = ProcessingHeader()
1095 #
1096 #
1097 # def __writeFirstHeader( self ):
1098 # """
1099 # Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1100 #
1101 # Affected:
1102 # __dataType
1103 #
1104 # Return:
1105 # None
1106 # """
1107 # self.__writeBasicHeader()
1108 # self.__wrSystemHeader()
1109 # self.__wrRadarControllerHeader()
1110 # self.__wrProcessingHeader()
1111 # self.__dataType = self.m_Voltage.dataType
1112 #
1113 #
1114 # def __writeBasicHeader( self, fp=None ):
1115 # """
1116 # Escribe solo el Basic header en el file creado
1117 #
1118 # Return:
1119 # None
1120 # """
1121 # if fp == None:
1122 # fp = self.__fp
1123 #
1124 # self.m_BasicHeader.write(fp)
1125 #
1126 #
1127 # def __wrSystemHeader( self, fp=None ):
1128 # """
1129 # Escribe solo el System header en el file creado
1130 #
1131 # Return:
1132 # None
1133 # """
1134 # if fp == None:
1135 # fp = self.__fp
1136 #
1137 # self.m_SystemHeader.write(fp)
1138 #
1139 #
1140 # def __wrRadarControllerHeader( self, fp=None ):
1141 # """
1142 # Escribe solo el RadarController header en el file creado
1143 #
1144 # Return:
1145 # None
1146 # """
1147 # if fp == None:
1148 # fp = self.__fp
1149 #
1150 # self.m_RadarControllerHeader.write(fp)
1151 #
1152 #
1153 # def __wrProcessingHeader( self, fp=None ):
1154 # """
1155 # Escribe solo el Processing header en el file creado
1156 #
1157 # Return:
1158 # None
1159 # """
1160 # if fp == None:
1161 # fp = self.__fp
1162 #
1163 # self.m_ProcessingHeader.write(fp)
1164 #
1165 # def __setNextFile( self ):
1166 # """
1167 # Determina el siguiente file que sera escrito
1168 #
1169 # Affected:
1170 # self.filename
1171 # self.__subfolder
1172 # self.__fp
1173 # self.__setFile
1174 # self.__flagNewFile
1175 #
1176 # Return:
1177 # 0 : Si el archivo no puede ser escrito
1178 # 1 : Si el archivo esta listo para ser escrito
1179 # """
1180 # #setFile = self.__setFile
1181 # ext = self.__ext
1182 # path = self.__path
1183 #
1184 # #setFile += 1
1185 #
1186 # if self.__fp != None:
1187 # self.__fp.close()
1188 #
1189 # """
1190 # timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
1191 # file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext)
1192 # subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1193 # tmp = os.path.join(path,subfolder)
1194 # if not(os.path.exists(tmp)):
1195 # os.mkdir(tmp)
1196 # """
1197 # ##################################
1198 # if self.m_BasicHeader.size <= 24: return 0 #no existe la suficiente data para ser escrita
1199 #
1200 # timeTuple = time.localtime( self.m_Voltage.m_BasicHeader.utc ) # utc from m_Voltage
1201 # subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1202 #
1203 # tmp = os.path.join( path, subfolder )
1204 # if not( os.path.exists(tmp) ):
1205 # os.mkdir(tmp)
1206 # self.__setFile = -1 #inicializo mi contador de seteo
1207 # else:
1208 # filesList = os.listdir( tmp )
1209 # if len( filesList ) > 0:
1210 # filesList = sorted( filesList, key=str.lower )
1211 # filen = filesList[-1]
1212 # # el filename debera tener el siguiente formato
1213 # # 0 1234 567 89A BCDE (hex)
1214 # # D YYYY DDD SSS .ext
1215 # if isNumber( filen[8:11] ):
1216 # self.__setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1217 # else:
1218 # self.__setFile = -1
1219 # else:
1220 # self.__setFile = -1 #inicializo mi contador de seteo
1221 #
1222 # setFile = self.__setFile
1223 # setFile += 1
1224 # file = 'D%4.4d%3.3d%3.3d%s' % ( timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
1225 # ##################################
1226 #
1227 # filename = os.path.join( path, subfolder, file )
1228 #
1229 # fp = open( filename,'wb' )
1230 #
1231 # self.__blocksCounter = 0
1232 #
1233 # #guardando atributos
1234 # self.filename = filename
1235 # self.__subfolder = subfolder
1236 # self.__fp = fp
1237 # self.__setFile = setFile
1238 # self.__flagNewFile = 1
1239 #
1240 # print 'Writing the file: %s'%self.filename
1241 #
1242 # self.__writeFirstHeader()
1243 #
1244 # return 1
1245 #
1246 #
1247 # def __setNewBlock( self ):
1248 # """
1249 # Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1250 #
1251 # Return:
1252 # 0 : si no pudo escribir nada
1253 # 1 : Si escribio el Basic el First Header
1254 # """
1255 # if self.__fp == None:
1256 # self.__setNextFile()
1257 #
1258 # if self.__flagNewFile:
1259 # return 1
1260 #
1261 # if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1262 # self.__writeBasicHeader()
1263 # return 1
1264 #
1265 # if not( self.__setNextFile() ):
1266 # return 0
1267 #
1268 # return 1
1269 #
1270 # def __writeBlock( self ):
1271 # """
1272 # Escribe el buffer en el file designado
1273 #
1274 # Affected:
1275 # self.__datablockIndex
1276 # self.__flagNewFile
1277 # self.__flagNewBlock
1278 # self.nWriteBlocks
1279 # self.__blocksCounter
1280 #
1281 # Return: None
1282 # """
1283 # data = numpy.zeros( self.__shapeBuffer, self.__dataType )
1284 #
1285 # data['real'] = self.datablock.real
1286 # data['imag'] = self.datablock.imag
1287 #
1288 # data = data.reshape( (-1) )
1289 #
1290 # data.tofile( self.__fp )
1291 #
1292 # self.datablock.fill(0)
1293 #
1294 # self.__datablockIndex = 0
1295 #
1296 # self.__flagNewFile = 0
1297 #
1298 # self.__flagNewBlock = 1
1299 #
1300 # self.nWriteBlocks += 1
1301 #
1302 # self.__blocksCounter += 1
1303 #
1304 #
1305 # def writeNextBlock( self ):
1306 # """
1307 # Selecciona el bloque siguiente de datos y los escribe en un file
1308 #
1309 # Return:
1310 # 0 : Si no hizo pudo escribir el bloque de datos
1311 # 1 : Si no pudo escribir el bloque de datos
1312 # """
1313 # if not(self.__setNewBlock()):
1314 # return 0
1315 #
1316 # self.__writeBlock()
1317 #
1318 # return 1
1319 #
1320 #
1321 # def __hasAllDataInBuffer( self ):
1322 # if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
1323 # return 1
1324 #
1325 # return 0
1326 #
1327 #
1328 # def putData( self ):
1329 # """
1330 # Setea un bloque de datos y luego los escribe en un file
1331 #
1332 # Affected:
1333 # self.__flagNewBlock
1334 # self.__datablockIndex
1335 #
1336 # Return:
1337 # 0 : Si no hay data o no hay mas files que puedan escribirse
1338 # 1 : Si se escribio la data de un bloque en un file
1339 # """
1340 # self.__flagNewBlock = 0
1341 #
1342 # if self.m_Voltage.flagNoData:
1343 # return 0
1344 #
1345 # if self.m_Voltage.flagNoContinuousBlock:
1346 #
1347 # self.datablock.fill(0)
1348 #
1349 # self.__datablockIndex = 0
1350 # self.__setNextFile()
1351 #
1352 # self.datablock[self.__datablockIndex,:,:] = self.m_Voltage.data
1353 #
1354 # self.__datablockIndex += 1
1355 #
1356 # if self.__hasAllDataInBuffer():
1357 #
1358 # self.__getHeader()
1359 # self.writeNextBlock()
1360 #
1361 # if self.flagNoMoreFiles:
1362 # #print 'Process finished'
1363 # return 0
1364 #
1365 # return 1
1366 #
1367 #
1368 # def __getHeader( self ):
1369 # """
1370 # Obtiene una copia del First Header
1371 #
1372 # Affected:
1373 # self.m_BasicHeader
1374 # self.m_SystemHeader
1375 # self.m_RadarControllerHeader
1376 # self.m_ProcessingHeader
1377 # self.__dataType
1378 #
1379 # Return:
1380 # None
1381 # """
1382 # self.m_BasicHeader = self.m_Voltage.m_BasicHeader.copy()
1383 # self.m_SystemHeader = self.m_Voltage.m_SystemHeader.copy()
1384 # self.m_RadarControllerHeader = self.m_Voltage.m_RadarControllerHeader.copy()
1385 # self.m_ProcessingHeader = self.m_Voltage.m_ProcessingHeader.copy()
1386 # self.__dataType = self.m_Voltage.dataType
1387 #
1388 #
1389 # def __setHeaderByFile( self ):
1390 #
1391 # format = self.__format
1392 # header = ['Basic','System','RadarController','Processing']
1393 #
1394 # fmtFromFile = None
1395 # headerFromFile = None
1396 #
1397 #
1398 # fileTable = self.__configHeaderFile
1399 #
1400 # if os.access(fileTable, os.R_OK):
1401 # import re, string
1402 #
1403 # f = open(fileTable,'r')
1404 # lines = f.read()
1405 # f.close()
1406 #
1407 # #Delete comments into expConfig
1408 # while 1:
1409 #
1410 # startComment = string.find(lines.lower(),'#')
1411 # if startComment == -1:
1412 # break
1413 # endComment = string.find(lines.lower(),'\n',startComment)
1414 # lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
1415 #
1416 # while expFromFile == None:
1417 #
1418 # currFmt = string.find(lines.lower(),'format="%s"' %(expName))
1419 # nextFmt = string.find(lines.lower(),'format',currFmt+10)
1420 #
1421 # if currFmt == -1:
1422 # break
1423 # if nextFmt == -1:
1424 # nextFmt = len(lines)-1
1425 #
1426 # fmtTable = lines[currFmt:nextFmt]
1427 # lines = lines[nextFmt:]
1428 #
1429 # fmtRead = self.__getValueFromArg(fmtTable,'format')
1430 # if fmtRead != format:
1431 # continue
1432 # fmtFromFile = fmtRead
1433 #
1434 # lines2 = fmtTable
1435 #
1436 # while headerFromFile == None:
1437 #
1438 # currHeader = string.find(lines2.lower(),'header="%s"' %(header))
1439 # nextHeader = string.find(lines2.lower(),'header',currHeader+10)
1440 #
1441 # if currHeader == -1:
1442 # break
1443 # if nextHeader == -1:
1444 # nextHeader = len(lines2)-1
1445 #
1446 # headerTable = lines2[currHeader:nextHeader]
1447 # lines2 = lines2[nextHeader:]
1448 #
1449 # headerRead = self.__getValueFromArg(headerTable,'site')
1450 # if not(headerRead in header):
1451 # continue
1452 # headerFromFile = headerRead
1453 #
1454 # if headerRead == 'Basic':
1455 # self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
1456 # self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
1457 # self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
1458 # self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
1459 # self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
1460 # self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
1461 # self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
1462 # self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
1463 #
1464 # else:
1465 # print "file access denied:%s"%fileTable
1466 # sys.exit(0)
1467 #
1468 #
1469 # def setup( self, path, set=0, format='rawdata' ):
1470 # """
1471 # Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1472 #
1473 # Inputs:
1474 # path : el path destino en el cual se escribiran los files a crear
1475 # format : formato en el cual sera salvado un file
1476 # set : el setebo del file
1477 #
1478 # Return:
1479 # 0 : Si no realizo un buen seteo
1480 # 1 : Si realizo un buen seteo
1481 # """
1482 # if format == 'hdf5':
1483 # ext = '.hdf5'
1484 # format = 'hdf5'
1485 # print 'call hdf5 library'
1486 # return 0
1487 #
1488 # if format == 'rawdata':
1489 # ext = '.r'
1490 # format = 'Jicamarca'
1491 #
1492 # #call to config_headers
1493 # #self.__setHeaderByFile()
1494 #
1495 # self.__path = path
1496 # self.__setFile = set - 1
1497 # self.__ext = ext
1498 # self.__format = format
1499 #
1500 # self.__getHeader()
1501 # self.__shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
1502 # self.m_ProcessingHeader.numHeights,
1503 # self.m_SystemHeader.numChannels )
1504 #
1505 # self.datablock = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex'))
1506 #
1507 ## if not(self.__setNextFile()):
1508 ## return 0
1509 # return 1
14
1510
15 class DataWriter:
1511 class JRODataWriter():
16
1512
17 def __init__(self):
1513 def __init__(self):
18 __buffer = 0
1514 pass No newline at end of file
19 __buffer_count = 0 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1760 +1,1758
1 '''
1 '''
2 File: SpectraIO.py
2 File: SpectraIO.py
3 Created on 20/02/2012
3 Created on 20/02/2012
4
4
5 @author $Author$
5 @author $Author$
6 @version $Id$
6 @version $Id$
7 '''
7 '''
8
8
9 import os, sys
9 import os, sys
10 import numpy
10 import numpy
11 import glob
11 import glob
12 import fnmatch
12 import fnmatch
13 import time, datetime
13 import time, datetime
14
14
15 path = os.path.split(os.getcwd())[0]
15 path = os.path.split(os.getcwd())[0]
16 sys.path.append(path)
16 sys.path.append(path)
17
17
18 from HeaderIO import *
18 from Model.JROHeader import *
19 from DataIO import DataReader
20 from DataIO import DataWriter
21
22 from Model.Spectra import Spectra
19 from Model.Spectra import Spectra
23
20
21 from DataIO import JRODataReader
22 from DataIO import JRODataWriter
24
23
25 def isFileOK(filename):
24 def isFileOK(filename):
26 """
25 """
27 Determina si la cabecera de un archivo es valido o no, si lo es entonces seria un archivo que podria contener data,
26 Determina si la cabecera de un archivo es valido o no, si lo es entonces seria un archivo que podria contener data,
28 si no seria un archivo invalido
27 si no seria un archivo invalido
29
28
30 Return:
29 Return:
31 True : si es un archivo valido
30 True : si es un archivo valido
32 False : si no es un archivo valido
31 False : si no es un archivo valido
33
32
34 Exceptions:
33 Exceptions:
35 Si al leer la cabecera esta no coincide con el tipo de las variables que la contienen entonces se dispara
34 Si al leer la cabecera esta no coincide con el tipo de las variables que la contienen entonces se dispara
36 una exception
35 una exception
37 """
36 """
38 m_BasicHeader = BasicHeader()
37 m_BasicHeader = BasicHeader()
39 m_ProcessingHeader = ProcessingHeader()
38 m_ProcessingHeader = ProcessingHeader()
40 m_RadarControllerHeader = RadarControllerHeader()
39 m_RadarControllerHeader = RadarControllerHeader()
41 m_SystemHeader = SystemHeader()
40 m_SystemHeader = SystemHeader()
42 fp = None
41 fp = None
43
42
44 try:
43 try:
45 fp = open( filename,'rb' ) #lectura binaria
44 fp = open( filename,'rb' ) #lectura binaria
46 m_BasicHeader.read(fp)
45 m_BasicHeader.read(fp)
47 m_SystemHeader.read(fp)
46 m_SystemHeader.read(fp)
48 m_RadarControllerHeader.read(fp)
47 m_RadarControllerHeader.read(fp)
49 m_ProcessingHeader.read(fp)
48 m_ProcessingHeader.read(fp)
50 fp.close()
49 fp.close()
51 except:
50 except:
52 if fp != None: fp.close()
51 if fp != None: fp.close()
53 return False
52 return False
54
53
55 return True
54 return True
56
55
57
56
58 def getlastFileFromPath(pathList,ext):
57 def getlastFileFromPath(pathList,ext):
59 """
58 """
60 Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
59 Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
61 al final de la depuracion devuelve el ultimo file de la lista que quedo.
60 al final de la depuracion devuelve el ultimo file de la lista que quedo.
62
61
63 Input:
62 Input:
64 pathList : lista conteniendo todos los filename completos que componen una determinada carpeta
63 pathList : lista conteniendo todos los filename completos que componen una determinada carpeta
65 ext : extension de los files contenidos en una carpeta
64 ext : extension de los files contenidos en una carpeta
66
65
67 Return:
66 Return:
68 El ultimo file de una determinada carpeta
67 El ultimo file de una determinada carpeta
69 """
68 """
70
69
71 filesList = []
70 filesList = []
72 filename = None
71 filename = None
73
72
74 # 0 1234 567 89A BCDE
73 # 0 1234 567 89A BCDE
75 # P YYYY DDD SSS .ext
74 # P YYYY DDD SSS .ext
76
75
77 for filename in pathList:
76 for filename in pathList:
78 year = filename[1:5]
77 year = filename[1:5]
79 doy = filename[5:8]
78 doy = filename[5:8]
80 leng = len( ext )
79 leng = len( ext )
81
80
82 if ( filename[-leng:].upper() != ext.upper() ) : continue
81 if ( filename[-leng:].upper() != ext.upper() ) : continue
83 if not( isNumber( year ) ) : continue
82 if not( isNumber( year ) ) : continue
84 if not( isNumber( doy ) ) : continue
83 if not( isNumber( doy ) ) : continue
85
84
86 filesList.append(filename)
85 filesList.append(filename)
87
86
88 if len( filesList ) > 0:
87 if len( filesList ) > 0:
89 filesList = sorted( filesList, key=str.lower )
88 filesList = sorted( filesList, key=str.lower )
90 filename = filesList[-1]
89 filename = filesList[-1]
91
90
92 return filename
91 return filename
93
92
94
93
95 def checkForRealPath(path,year,doy,set,ext):
94 def checkForRealPath(path,year,doy,set,ext):
96 """
95 """
97 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
96 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
98 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
97 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
99 el path exacto de un determinado file.
98 el path exacto de un determinado file.
100
99
101 Example :
100 Example :
102 nombre correcto del file es ../RAWDATA/D2009307/P2009307367
101 nombre correcto del file es ../RAWDATA/D2009307/P2009307367
103
102
104 Entonces la funcion prueba con las siguientes combinaciones
103 Entonces la funcion prueba con las siguientes combinaciones
105 ../RAWDATA/d2009307/p2009307367
104 ../RAWDATA/d2009307/p2009307367
106 ../RAWDATA/d2009307/P2009307367
105 ../RAWDATA/d2009307/P2009307367
107 ../RAWDATA/D2009307/p2009307367
106 ../RAWDATA/D2009307/p2009307367
108 ../RAWDATA/D2009307/P2009307367
107 ../RAWDATA/D2009307/P2009307367
109 siendo para este caso, la ultima combinacion de letras, identica al file buscado
108 siendo para este caso, la ultima combinacion de letras, identica al file buscado
110
109
111 Return:
110 Return:
112 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
111 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
113 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
112 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
114 para el filename
113 para el filename
115 """
114 """
116 filepath = None
115 filepath = None
117 find_flag = False
116 find_flag = False
118 filename = None
117 filename = None
119
118
120 for dir in "dD": #barrido por las dos combinaciones posibles de "D"
119 for dir in "dD": #barrido por las dos combinaciones posibles de "D"
121 for fil in "pP": #barrido por las dos combinaciones posibles de "D"
120 for fil in "pP": #barrido por las dos combinaciones posibles de "D"
122 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
121 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
123 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext (p=d o p=D)
122 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext (p=d o p=D)
124 filepath = os.path.join( path, doypath, filename ) #formo el path completo
123 filepath = os.path.join( path, doypath, filename ) #formo el path completo
125 if os.path.exists( filepath ): #verifico que exista
124 if os.path.exists( filepath ): #verifico que exista
126 find_flag = True
125 find_flag = True
127 break
126 break
128 if find_flag:
127 if find_flag:
129 break
128 break
130
129
131 if not(find_flag):
130 if not(find_flag):
132 return None, filename
131 return None, filename
133
132
134 return filepath, filename
133 return filepath, filename
135
134
136 def isNumber(str):
135 def isNumber(str):
137 """
136 """
138 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
137 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
139
138
140 Excepciones:
139 Excepciones:
141 Si un determinado string no puede ser convertido a numero
140 Si un determinado string no puede ser convertido a numero
142 Input:
141 Input:
143 str, string al cual se le analiza para determinar si convertible a un numero o no
142 str, string al cual se le analiza para determinar si convertible a un numero o no
144
143
145 Return:
144 Return:
146 True : si el string es uno numerico
145 True : si el string es uno numerico
147 False : no es un string numerico
146 False : no es un string numerico
148 """
147 """
149 try:
148 try:
150 float( str )
149 float( str )
151 return True
150 return True
152 except:
151 except:
153 return False
152 return False
154
153
155
154
156
155
157 def isThisFileinRange(filename,startUTSeconds,endUTSeconds):
156 def isThisFileinRange(filename,startUTSeconds,endUTSeconds):
158 """
157 """
159 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
158 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
160 o no dentro del rango de fecha especificado.
159 o no dentro del rango de fecha especificado.
161
160
162 Inputs:
161 Inputs:
163 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
162 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
164
163
165 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
164 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
166 segundos contados desde 01/01/1970.
165 segundos contados desde 01/01/1970.
167
166
168 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
167 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
169 segundos contados desde 01/01/1970.
168 segundos contados desde 01/01/1970.
170
169
171 Return:
170 Return:
172 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
171 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
173 fecha especificado, de lo contrario retorna False.
172 fecha especificado, de lo contrario retorna False.
174
173
175 Excepciones:
174 Excepciones:
176 Si el archivo no existe o no puede ser abierto
175 Si el archivo no existe o no puede ser abierto
177 Si la cabecera no puede ser leida.
176 Si la cabecera no puede ser leida.
178 """
177 """
179 m_BasicHeader = BasicHeader()
178 m_BasicHeader = BasicHeader()
180
179
181 try:
180 try:
182 fp = open( filename,'rb' ) #lectura binaria
181 fp = open( filename,'rb' ) #lectura binaria
183 except:
182 except:
184 raise IOError, "The file %s can't be opened" %(filename)
183 raise IOError, "The file %s can't be opened" %(filename)
185
184
186 if not(m_BasicHeader.read(fp)):
185 if not(m_BasicHeader.read(fp)):
187 raise IOError, "The file %s has not a valid header" %(filename)
186 raise IOError, "The file %s has not a valid header" %(filename)
188
187
189 fp.close()
188 fp.close()
190
189
191 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
190 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
192 return 0
191 return 0
193
192
194 return 1
193 return 1
195
194
196
195
197 class SpectraReader(DataReader):
196 class SpectraReader( JRODataReader ):
198 """
197 """
199 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
198 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
200 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
199 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
201 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
200 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
202
201
203 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
202 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
204 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
203 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
205 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
204 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
206 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
205 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
207
206
208 Example:
207 Example:
209 dpath = "/home/myuser/data"
208 dpath = "/home/myuser/data"
210
209
211 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
210 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
212
211
213 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
212 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
214
213
215 readerObj = SpectraReader()
214 readerObj = SpectraReader()
216
215
217 readerObj.setup(dpath, startTime, endTime)
216 readerObj.setup(dpath, startTime, endTime)
218
217
219 while(True):
218 while(True):
220
219
221 readerObj.getData()
220 readerObj.getData()
222
221
223 print readerObj.m_Spectra.data
222 print readerObj.m_Spectra.data
224
223
225 if readerObj.noMoreFiles:
224 if readerObj.noMoreFiles:
226 break
225 break
227
226
228 """
227 """
229
228
230 #speed of light
229 #speed of light
231 __c = 3E8
230 __c = 3E8
232
231
233
232
234 def __init__(self,m_Spectra=None):
233 def __init__(self,m_Spectra=None):
235 """
234 """
236 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
235 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
237
236
238 Inputs:
237 Inputs:
239 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
238 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
240 almacenar un perfil de datos cada vez que se haga un requerimiento
239 almacenar un perfil de datos cada vez que se haga un requerimiento
241 (getData). El perfil sera obtenido a partir del buffer de datos,
240 (getData). El perfil sera obtenido a partir del buffer de datos,
242 si el buffer esta vacio se hara un nuevo proceso de lectura de un
241 si el buffer esta vacio se hara un nuevo proceso de lectura de un
243 bloque de datos.
242 bloque de datos.
244 Si este parametro no es pasado se creara uno internamente.
243 Si este parametro no es pasado se creara uno internamente.
245
244
246 Affected:
245 Affected:
247 self.m_Spectra
246 self.m_Spectra
248 self.m_BasicHeader
247 self.m_BasicHeader
249 self.m_SystemHeader
248 self.m_SystemHeader
250 self.m_RadarControllerHeader
249 self.m_RadarControllerHeader
251 self.m_ProcessingHeader
250 self.m_ProcessingHeader
252
251
253 Return : None
252 Return : None
254 """
253 """
255 if m_Spectra == None:
254 if m_Spectra == None:
256 m_Spectra = Spectra()
255 m_Spectra = Spectra()
257
256
258 if not( isinstance(m_Spectra, Spectra) ):
257 if not( isinstance(m_Spectra, Spectra) ):
259 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
258 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
260
259
261 self.m_Spectra = m_Spectra
260 self.m_Spectra = m_Spectra
262
261
263 self.m_BasicHeader = BasicHeader()
262 self.m_BasicHeader = BasicHeader()
264
263
265 self.m_SystemHeader = SystemHeader()
264 self.m_SystemHeader = SystemHeader()
266
265
267 self.m_RadarControllerHeader = RadarControllerHeader()
266 self.m_RadarControllerHeader = RadarControllerHeader()
268
267
269 self.m_ProcessingHeader = ProcessingHeader()
268 self.m_ProcessingHeader = ProcessingHeader()
270
269
271 self.__fp = None
270 self.__fp = None
272
271
273 self.__idFile = None
272 self.__idFile = None
274
273
275 self.__startDateTime = None
274 self.__startDateTime = None
276
275
277 self.__endDateTime = None
276 self.__endDateTime = None
278
277
279 self.__dataType = None
278 self.__dataType = None
280
279
281 self.__fileSizeByHeader = 0
280 self.__fileSizeByHeader = 0
282
281
283 self.__pathList = []
282 self.__pathList = []
284
283
285 self.filenameList = []
284 self.filenameList = []
286
285
287 self.__lastUTTime = 0
286 self.__lastUTTime = 0
288
287
289 self.__maxTimeStep = 30
288 self.__maxTimeStep = 30
290
289
291 self.__flagIsNewFile = 0
290 self.__flagIsNewFile = 0
292
291
293 self.flagResetProcessing = 0
292 self.flagResetProcessing = 0
294
293
295 self.flagIsNewBlock = 0
294 self.flagIsNewBlock = 0
296
295
297 self.noMoreFiles = 0
296 self.noMoreFiles = 0
298
297
299 self.nReadBlocks = 0
298 self.nReadBlocks = 0
300
299
301 self.online = 0
300 self.online = 0
302
301
303 self.firstHeaderSize = 0
302 self.firstHeaderSize = 0
304
303
305 self.basicHeaderSize = 24
304 self.basicHeaderSize = 24
306
305
307 self.filename = None
306 self.filename = None
308
307
309 self.fileSize = None
308 self.fileSize = None
310
309
311 self.__data_spc = None
310 self.__data_spc = None
312 self.__data_cspc = None
311 self.__data_cspc = None
313 self.__data_dc = None
312 self.__data_dc = None
314
313
315 self.nChannels = 0
314 self.nChannels = 0
316 self.nPairs = 0
315 self.nPairs = 0
317
316
318 self.__pts2read_SelfSpectra = 0
317 self.__pts2read_SelfSpectra = 0
319 self.__pts2read_CrossSpectra = 0
318 self.__pts2read_CrossSpectra = 0
320 self.__pts2read_DCchannels = 0
319 self.__pts2read_DCchannels = 0
321 self.__blocksize = 0
320 self.__blocksize = 0
322
321
323 self.__datablockIndex = 0
322 self.__datablockIndex = 0
324
323
325 self.__ippSeconds = 0
324 self.__ippSeconds = 0
326
325
327 self.nSelfChannels = 0
326 self.nSelfChannels = 0
328
327
329 self.nCrossPairs = 0
328 self.nCrossPairs = 0
330
329
331 self.datablock_id = 9999
330 self.datablock_id = 9999
332
331
333 self.__delay = 2 #seconds
332 self.__delay = 2 #seconds
334 self.__nTries = 3 #quantity tries
333 self.__nTries = 3 #quantity tries
335 self.__nFiles = 3 #number of files for searching
334 self.__nFiles = 3 #number of files for searching
336 self.__year = 0
335 self.__year = 0
337 self.__doy = 0
336 self.__doy = 0
338 self.__set = 0
337 self.__set = 0
339 self.__ext = None
338 self.__ext = None
340 self.__path = None
339 self.__path = None
341 self.nBlocks = 0
340 self.nBlocks = 0
342
341
343 def __rdSystemHeader(self,fp=None):
342 def __rdSystemHeader(self,fp=None):
344 """
343 """
345 Lectura del System Header
344 Lectura del System Header
346
345
347 Inputs:
346 Inputs:
348 fp : file pointer
347 fp : file pointer
349
348
350 Affected:
349 Affected:
351 self.m_SystemHeader
350 self.m_SystemHeader
352
351
353 Return: None
352 Return: None
354 """
353 """
355 if fp == None:
354 if fp == None:
356 fp = self.__fp
355 fp = self.__fp
357
356
358 self.m_SystemHeader.read( fp )
357 self.m_SystemHeader.read( fp )
359
358
360
359
361
360
362 def __rdRadarControllerHeader(self,fp=None):
361 def __rdRadarControllerHeader(self,fp=None):
363 """
362 """
364 Lectura del Radar Controller Header
363 Lectura del Radar Controller Header
365
364
366 Inputs:
365 Inputs:
367 fp : file pointer
366 fp : file pointer
368
367
369 Affected:
368 Affected:
370 self.m_RadarControllerHeader
369 self.m_RadarControllerHeader
371
370
372 Return: None
371 Return: None
373 """
372 """
374 if fp == None:
373 if fp == None:
375 fp = self.__fp
374 fp = self.__fp
376
375
377 self.m_RadarControllerHeader.read(fp)
376 self.m_RadarControllerHeader.read(fp)
378
377
379
378
380 def __rdProcessingHeader(self,fp=None):
379 def __rdProcessingHeader(self,fp=None):
381 """
380 """
382 Lectura del Processing Header
381 Lectura del Processing Header
383
382
384 Inputs:
383 Inputs:
385 fp : file pointer
384 fp : file pointer
386
385
387 Affected:
386 Affected:
388 self.m_ProcessingHeader
387 self.m_ProcessingHeader
389
388
390 Return: None
389 Return: None
391 """
390 """
392 if fp == None:
391 if fp == None:
393 fp = self.__fp
392 fp = self.__fp
394
393
395 self.m_ProcessingHeader.read(fp)
394 self.m_ProcessingHeader.read(fp)
396
395
397
396
398 def __rdBasicHeader(self,fp=None):
397 def __rdBasicHeader(self,fp=None):
399 """
398 """
400 Lectura del Basic Header
399 Lectura del Basic Header
401
400
402 Inputs:
401 Inputs:
403 fp : file pointer
402 fp : file pointer
404
403
405 Affected:
404 Affected:
406 self.m_BasicHeader
405 self.m_BasicHeader
407
406
408 Return: None
407 Return: None
409 """
408 """
410 if fp == None:
409 if fp == None:
411 fp = self.__fp
410 fp = self.__fp
412
411
413 self.m_BasicHeader.read(fp)
412 self.m_BasicHeader.read(fp)
414
413
415
414
416 def __readFirstHeader(self):
415 def __readFirstHeader(self):
417 """
416 """
418 Lectura del First Header, es decir el Basic Header y el Long Header
417 Lectura del First Header, es decir el Basic Header y el Long Header
419
418
420 Affected:
419 Affected:
421 self.m_BasicHeader
420 self.m_BasicHeader
422 self.m_SystemHeader
421 self.m_SystemHeader
423 self.m_RadarControllerHeader
422 self.m_RadarControllerHeader
424 self.m_ProcessingHeader
423 self.m_ProcessingHeader
425 self.firstHeaderSize
424 self.firstHeaderSize
426 self.__heights
425 self.__heights
427 self.__dataType
426 self.__dataType
428 self.__fileSizeByHeader
427 self.__fileSizeByHeader
429 self.__ippSeconds
428 self.__ippSeconds
430 self.nChannels
429 self.nChannels
431 self.nPairs
430 self.nPairs
432 self.__pts2read_SelfSpectra
431 self.__pts2read_SelfSpectra
433 self.__pts2read_CrossSpectra
432 self.__pts2read_CrossSpectra
434
433
435 Return: None
434 Return: None
436 """
435 """
437 self.__rdBasicHeader()
436 self.__rdBasicHeader()
438 self.__rdSystemHeader()
437 self.__rdSystemHeader()
439 self.__rdRadarControllerHeader()
438 self.__rdRadarControllerHeader()
440 self.__rdProcessingHeader()
439 self.__rdProcessingHeader()
441 self.firstHeaderSize = self.m_BasicHeader.size
440 self.firstHeaderSize = self.m_BasicHeader.size
442
441
443 data_type = int( numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR) )
442 data_type = int( numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR) )
444 if data_type == 0:
443 if data_type == 0:
445 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
444 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
446
445
447 elif data_type == 1:
446 elif data_type == 1:
448 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
447 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
449
448
450 elif data_type == 2:
449 elif data_type == 2:
451 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
450 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
452
451
453 elif data_type == 3:
452 elif data_type == 3:
454 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
453 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
455
454
456 elif data_type == 4:
455 elif data_type == 4:
457 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
456 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
458
457
459 elif data_type == 5:
458 elif data_type == 5:
460 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
459 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
461
460
462 else:
461 else:
463 raise ValueError, 'Data type was not defined'
462 raise ValueError, 'Data type was not defined'
464
463
465 xi = self.m_ProcessingHeader.firstHeight
464 xi = self.m_ProcessingHeader.firstHeight
466 step = self.m_ProcessingHeader.deltaHeight
465 step = self.m_ProcessingHeader.deltaHeight
467 xf = xi + self.m_ProcessingHeader.numHeights*step
466 xf = xi + self.m_ProcessingHeader.numHeights*step
468
467
469 self.__heights = numpy.arange(xi, xf, step)
468 self.__heights = numpy.arange(xi, xf, step)
470
469
471 self.__dataType = tmp
470 self.__dataType = tmp
472 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
471 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
473 self.__ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.__c
472 self.__ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.__c
474
473
475 self.nChannels = 0
474 self.nChannels = 0
476 self.nPairs = 0
475 self.nPairs = 0
477
476
478 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
477 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
479 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
478 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
480 self.nChannels = self.nChannels + 1
479 self.nChannels = self.nChannels + 1
481 else:
480 else:
482 self.nPairs = self.nPairs + 1
481 self.nPairs = self.nPairs + 1
483
482
484 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights
483 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights
485 self.__pts2read_SelfSpectra = int( pts2read * self.nChannels )
484 self.__pts2read_SelfSpectra = int( pts2read * self.nChannels )
486 self.__pts2read_CrossSpectra = int( pts2read * self.nPairs )
485 self.__pts2read_CrossSpectra = int( pts2read * self.nPairs )
487 self.__pts2read_DCchannels = int( self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels )
486 self.__pts2read_DCchannels = int( self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels )
488
487
489 self.__blocksize = self.__pts2read_SelfSpectra + self.__pts2read_CrossSpectra + self.__pts2read_DCchannels
488 self.__blocksize = self.__pts2read_SelfSpectra + self.__pts2read_CrossSpectra + self.__pts2read_DCchannels
490
489
491 self.m_Spectra.nChannels = self.nChannels
490 self.m_Spectra.nChannels = self.nChannels
492 self.m_Spectra.nPairs = self.nPairs
491 self.m_Spectra.nPairs = self.nPairs
493
492
494
493
495 def __setNextFileOnline(self):
494 def __setNextFileOnline(self):
496 """
495 """
497 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
496 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
498 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
497 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
499 siguientes.
498 siguientes.
500
499
501 Affected:
500 Affected:
502 self.__flagIsNewFile
501 self.__flagIsNewFile
503 self.filename
502 self.filename
504 self.fileSize
503 self.fileSize
505 self.__fp
504 self.__fp
506 self.__set
505 self.__set
507 self.noMoreFiles
506 self.noMoreFiles
508
507
509 Return:
508 Return:
510 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
509 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
511 1 : si el file fue abierto con exito y esta listo a ser leido
510 1 : si el file fue abierto con exito y esta listo a ser leido
512
511
513 Excepciones:
512 Excepciones:
514 Si un determinado file no puede ser abierto
513 Si un determinado file no puede ser abierto
515 """
514 """
516 countFiles = 0
515 countFiles = 0
517 countTries = 0
516 countTries = 0
518
517
519 #fileStatus = 0
518 #fileStatus = 0
520 notFirstTime_flag = False
519 notFirstTime_flag = False
521 fileOk_flag = False
520 fileOk_flag = False
522 changeDir_flag = False
521 changeDir_flag = False
523
522
524 fileSize = 0
523 fileSize = 0
525 fp = None
524 fp = None
526
525
527 self.__flagIsNewFile = 0
526 self.__flagIsNewFile = 0
528
527
529 while(True): #este loop permite llevar la cuenta de intentos, de files y carpetas,
528 while(True): #este loop permite llevar la cuenta de intentos, de files y carpetas,
530 #si no encuentra alguno sale del bucle
529 #si no encuentra alguno sale del bucle
531
530
532 countFiles += 1
531 countFiles += 1
533
532
534 if countFiles > (self.__nFiles + 1):
533 if countFiles > (self.__nFiles + 1):
535 break
534 break
536
535
537 self.__set += 1
536 self.__set += 1
538
537
539 if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
538 if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
540 self.__set = 0
539 self.__set = 0
541 self.__doy += 1
540 self.__doy += 1
542 changeDir_flag = True
541 changeDir_flag = True
543
542
544 file = None
543 file = None
545 filename = None
544 filename = None
546 fileOk_flag = False
545 fileOk_flag = False
547
546
548 #busca el 1er file disponible
547 #busca el 1er file disponible
549 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
548 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
550
549
551 if file == None:
550 if file == None:
552 if notFirstTime_flag: #si no es la primera vez que busca el file entonces no espera y busca for el siguiente file
551 if notFirstTime_flag: #si no es la primera vez que busca el file entonces no espera y busca for el siguiente file
553 print "\tsearching next \"%s\" file ..." % ( filename )
552 print "\tsearching next \"%s\" file ..." % ( filename )
554 continue
553 continue
555 else: #si es la primera vez que busca el file entonces espera self.__nTries veces hasta encontrarlo o no
554 else: #si es la primera vez que busca el file entonces espera self.__nTries veces hasta encontrarlo o no
556 for nTries in range( self.__nTries ):
555 for nTries in range( self.__nTries ):
557 print "\twaiting new \"%s\" file, try %03d ..." % ( filename, nTries+1 )
556 print "\twaiting new \"%s\" file, try %03d ..." % ( filename, nTries+1 )
558 time.sleep( self.__delay )
557 time.sleep( self.__delay )
559
558
560 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
559 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
561 if file != None:
560 if file != None:
562 fileOk_flag = True
561 fileOk_flag = True
563 break
562 break
564
563
565 if not( fileOk_flag ): #no encontro ningun file valido a leer
564 if not( fileOk_flag ): #no encontro ningun file valido a leer
566 notFirstTime_flag = True
565 notFirstTime_flag = True
567 continue
566 continue
568
567
569
568
570 """countTries = 0
569 """countTries = 0
571
570
572 #espero hasta encontrar el 1er file disponible
571 #espero hasta encontrar el 1er file disponible
573 while( True ):
572 while( True ):
574
573
575 countTries += 1
574 countTries += 1
576 if( countTries >= self.__nTries ): #checkeo que no haya ido mas alla de la cantidad de intentos
575 if( countTries >= self.__nTries ): #checkeo que no haya ido mas alla de la cantidad de intentos
577 break
576 break
578
577
579 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
578 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
580 if file != None:
579 if file != None:
581 break
580 break
582
581
583 if notFirstTime_flag: #este flag me sirve solo para esperar por el 1er file, en lo siguientes no espera solo checkea si existe o no
582 if notFirstTime_flag: #este flag me sirve solo para esperar por el 1er file, en lo siguientes no espera solo checkea si existe o no
584 countTries = self.__nTries
583 countTries = self.__nTries
585 print "\tsearching next \"%s\" file ..." % filename
584 print "\tsearching next \"%s\" file ..." % filename
586 break
585 break
587
586
588 print "\twaiting new \"%s\" file ..." % filename
587 print "\twaiting new \"%s\" file ..." % filename
589 time.sleep( self.__delay )
588 time.sleep( self.__delay )
590
589
591 if countTries >= self.__nTries: #se realizaron n intentos y no hubo un file nuevo
590 if countTries >= self.__nTries: #se realizaron n intentos y no hubo un file nuevo
592 notFirstTime_flag = True
591 notFirstTime_flag = True
593 continue #vuelvo al inico del while principal
592 continue #vuelvo al inico del while principal
594 """
593 """
595
594
596 #una vez que se obtuvo el 1er file valido se procede a checkear si si tamanho es suficiente para empezar a leerlo
595 #una vez que se obtuvo el 1er file valido se procede a checkear si si tamanho es suficiente para empezar a leerlo
597 currentSize = os.path.getsize( file )
596 currentSize = os.path.getsize( file )
598 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
597 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
599
598
600 #si el tamanho es suficiente entonces deja de buscar
599 #si el tamanho es suficiente entonces deja de buscar
601 if currentSize > neededSize:
600 if currentSize > neededSize:
602 fileOk_flag = True
601 fileOk_flag = True
603 break
602 break
604
603
605 fileOk_flag = False
604 fileOk_flag = False
606 #si el file no tiene el tamanho necesario se espera una cierta cantidad de tiempo
605 #si el file no tiene el tamanho necesario se espera una cierta cantidad de tiempo
607 #por una cierta cantidad de veces hasta que el contenido del file sea valido
606 #por una cierta cantidad de veces hasta que el contenido del file sea valido
608 if changeDir_flag: #si al buscar un file cambie de directorio ya no espero y sigo con el siguiente file
607 if changeDir_flag: #si al buscar un file cambie de directorio ya no espero y sigo con el siguiente file
609 print "\tsearching next \"%s\" file ..." % filename
608 print "\tsearching next \"%s\" file ..." % filename
610 changeDir_flag = False
609 changeDir_flag = False
611 continue
610 continue
612
611
613 for nTries in range( self.__nTries ):
612 for nTries in range( self.__nTries ):
614 print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 )
613 print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 )
615 time.sleep( self.__delay )
614 time.sleep( self.__delay )
616
615
617 currentSize = os.path.getsize( file )
616 currentSize = os.path.getsize( file )
618 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
617 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
619
618
620 if currentSize > neededSize:
619 if currentSize > neededSize:
621 fileOk_flag = True
620 fileOk_flag = True
622 break
621 break
623
622
624 if fileOk_flag: #si encontro un file valido sale del bucle y deja de buscar
623 if fileOk_flag: #si encontro un file valido sale del bucle y deja de buscar
625 break
624 break
626
625
627 print "Skipping the file \"%s\" due to this files is empty" % filename
626 print "Skipping the file \"%s\" due to this files is empty" % filename
628 countFiles = 0
627 countFiles = 0
629
628
630 if fileOk_flag:
629 if fileOk_flag:
631 self.fileSize = os.path.getsize( file ) #fileSize
630 self.fileSize = os.path.getsize( file ) #fileSize
632 self.filename = file#name
631 self.filename = file#name
633 self.__flagIsNewFile = 1
632 self.__flagIsNewFile = 1
634 self.__fp = open(file)
633 self.__fp = open(file)
635 self.noMoreFiles = 0
634 self.noMoreFiles = 0
636 print 'Setting the file: %s' % file #name
635 print 'Setting the file: %s' % file #name
637 else:
636 else:
638 self.fileSize = 0
637 self.fileSize = 0
639 self.filename = None
638 self.filename = None
640 self.__fp = None
639 self.__fp = None
641 self.noMoreFiles = 1
640 self.noMoreFiles = 1
642 print 'No more Files'
641 print 'No more Files'
643
642
644 return fileOk_flag
643 return fileOk_flag
645
644
646
645
647 def __setNextFileOffline( self ):
646 def __setNextFileOffline( self ):
648 """
647 """
649 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
648 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
650
649
651 Affected:
650 Affected:
652 self.__flagIsNewFile
651 self.__flagIsNewFile
653 self.__idFile
652 self.__idFile
654 self.filename
653 self.filename
655 self.fileSize
654 self.fileSize
656 self.__fp
655 self.__fp
657
656
658 Return:
657 Return:
659 0 : si un determinado file no puede ser abierto
658 0 : si un determinado file no puede ser abierto
660 1 : si el file fue abierto con exito
659 1 : si el file fue abierto con exito
661
660
662 Excepciones:
661 Excepciones:
663 Si un determinado file no puede ser abierto
662 Si un determinado file no puede ser abierto
664 """
663 """
665 idFile = self.__idFile
664 idFile = self.__idFile
666 self.__flagIsNewFile = 0
665 self.__flagIsNewFile = 0
667
666
668 while(True):
667 while(True):
669 idFile += 1
668 idFile += 1
670
669
671 if not( idFile < len(self.filenameList) ):
670 if not( idFile < len(self.filenameList) ):
672 self.noMoreFiles = 1
671 self.noMoreFiles = 1
673 print 'No more Files'
672 print 'No more Files'
674 return 0
673 return 0
675
674
676 filename = self.filenameList[idFile]
675 filename = self.filenameList[idFile]
677 fileSize = os.path.getsize(filename)
676 fileSize = os.path.getsize(filename)
678
677
679 try:
678 try:
680 fp = open( filename, 'rb' )
679 fp = open( filename, 'rb' )
681 except:
680 except:
682 raise IOError, "The file %s can't be opened" %filename
681 raise IOError, "The file %s can't be opened" %filename
683
682
684 currentSize = fileSize - fp.tell()
683 currentSize = fileSize - fp.tell()
685 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
684 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
686
685
687 if (currentSize < neededSize):
686 if (currentSize < neededSize):
688 print "Skipping the file %s due to it hasn't enough data" %filename
687 print "Skipping the file %s due to it hasn't enough data" %filename
689 fp.close()
688 fp.close()
690 continue
689 continue
691
690
692 break
691 break
693
692
694 self.__flagIsNewFile = 1
693 self.__flagIsNewFile = 1
695 self.__idFile = idFile
694 self.__idFile = idFile
696 self.filename = filename
695 self.filename = filename
697 self.fileSize = fileSize
696 self.fileSize = fileSize
698 self.__fp = fp
697 self.__fp = fp
699
698
700 print 'Setting the file: %s'%self.filename
699 print 'Setting the file: %s'%self.filename
701
700
702 return 1
701 return 1
703
702
704
703
705 def __setNextFile( self ):
704 def __setNextFile( self ):
706 """
705 """
707 Determina el siguiente file a leer y si hay uno disponible lee el First Header
706 Determina el siguiente file a leer y si hay uno disponible lee el First Header
708
707
709 Affected:
708 Affected:
710 self.m_BasicHeader
709 self.m_BasicHeader
711 self.m_SystemHeader
710 self.m_SystemHeader
712 self.m_RadarControllerHeader
711 self.m_RadarControllerHeader
713 self.m_ProcessingHeader
712 self.m_ProcessingHeader
714 self.firstHeaderSize
713 self.firstHeaderSize
715
714
716 Return:
715 Return:
717 0 : Si no hay files disponibles
716 0 : Si no hay files disponibles
718 1 : Si hay mas files disponibles
717 1 : Si hay mas files disponibles
719 """
718 """
720 if self.__fp != None:
719 if self.__fp != None:
721 self.__fp.close()
720 self.__fp.close()
722
721
723 if self.online:
722 if self.online:
724 newFile = self.__setNextFileOnline()
723 newFile = self.__setNextFileOnline()
725 else:
724 else:
726 newFile = self.__setNextFileOffline()
725 newFile = self.__setNextFileOffline()
727
726
728 if self.noMoreFiles:
727 if self.noMoreFiles:
729 sys.exit(0)
728 sys.exit(0)
730
729
731 if not(newFile):
730 if not(newFile):
732 return 0
731 return 0
733
732
734 self.__readFirstHeader()
733 self.__readFirstHeader()
735 self.nBlocks = 0
734 self.nBlocks = 0
736 return 1
735 return 1
737
736
738
737
739 def __setNewBlock(self):
738 def __setNewBlock(self):
740 """
739 """
741 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
740 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
742
741
743 Affected:
742 Affected:
744 self.m_BasicHeader
743 self.m_BasicHeader
745 self.flagResetProcessing
744 self.flagResetProcessing
746 self.ns
745 self.ns
747
746
748 Return:
747 Return:
749 0 : Si el file no tiene un Basic Header que pueda ser leido
748 0 : Si el file no tiene un Basic Header que pueda ser leido
750 1 : Si se pudo leer el Basic Header
749 1 : Si se pudo leer el Basic Header
751 """
750 """
752 if self.__fp == None:
751 if self.__fp == None:
753 return 0
752 return 0
754
753
755 if self.__flagIsNewFile:
754 if self.__flagIsNewFile:
756 return 1
755 return 1
757
756
758 currentSize = self.fileSize - self.__fp.tell()
757 currentSize = self.fileSize - self.__fp.tell()
759 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
758 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
760
759
761 #If there is enough data setting new data block
760 #If there is enough data setting new data block
762 if ( currentSize >= neededSize ):
761 if ( currentSize >= neededSize ):
763 self.__rdBasicHeader()
762 self.__rdBasicHeader()
764 return 1
763 return 1
765
764
766 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
765 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
767 elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
766 elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
768 for nTries in range( self.__nTries ):
767 for nTries in range( self.__nTries ):
769
768
770 fpointer = self.__fp.tell()
769 fpointer = self.__fp.tell()
771 self.__fp.close()
770 self.__fp.close()
772
771
773 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
772 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
774 time.sleep( self.__delay )
773 time.sleep( self.__delay )
775
774
776 self.__fp = open( self.filename, 'rb' )
775 self.__fp = open( self.filename, 'rb' )
777 self.__fp.seek( fpointer )
776 self.__fp.seek( fpointer )
778
777
779 self.fileSize = os.path.getsize( self.filename )
778 self.fileSize = os.path.getsize( self.filename )
780 currentSize = self.fileSize - self.__fp.tell()
779 currentSize = self.fileSize - self.__fp.tell()
781 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
780 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
782
781
783 if ( currentSize >= neededSize ):
782 if ( currentSize >= neededSize ):
784 self.__rdBasicHeader()
783 self.__rdBasicHeader()
785 return 1
784 return 1
786
785
787 #Setting new file
786 #Setting new file
788 if not( self.__setNextFile() ):
787 if not( self.__setNextFile() ):
789 return 0
788 return 0
790
789
791 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
790 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
792
791
793 self.flagResetProcessing = 0
792 self.flagResetProcessing = 0
794
793
795 if deltaTime > self.__maxTimeStep:
794 if deltaTime > self.__maxTimeStep:
796 self.flagResetProcessing = 1
795 self.flagResetProcessing = 1
797 #self.nReadBlocks = 0
796 #self.nReadBlocks = 0
798
797
799 return 1
798 return 1
800
799
801
800
802 def __readBlock(self):
801 def __readBlock(self):
803 """
802 """
804 Lee el bloque de datos desde la posicion actual del puntero del archivo
803 Lee el bloque de datos desde la posicion actual del puntero del archivo
805 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
804 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
806 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
805 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
807 es seteado a 0
806 es seteado a 0
808
807
809 Return: None
808 Return: None
810
809
811 Variables afectadas:
810 Variables afectadas:
812 self.__datablockIndex
811 self.__datablockIndex
813 self.__flagIsNewFile
812 self.__flagIsNewFile
814 self.flagIsNewBlock
813 self.flagIsNewBlock
815 self.nReadBlocks
814 self.nReadBlocks
816 self.__data_spc
815 self.__data_spc
817 self.__data_cspc
816 self.__data_cspc
818 self.__data_dc
817 self.__data_dc
819
818
820 Exceptions:
819 Exceptions:
821 Si un bloque leido no es un bloque valido
820 Si un bloque leido no es un bloque valido
822 """
821 """
823 #self.datablock_id = 0
822 #self.datablock_id = 0
824 #self.__flagIsNewFile = 0
823 #self.__flagIsNewFile = 0
825 #self.flagIsNewBlock = 1
824 #self.flagIsNewBlock = 1
826
825
827 blockOk_flag = False
826 blockOk_flag = False
828 fpointer = self.__fp.tell()
827 fpointer = self.__fp.tell()
829
828
830 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra )
829 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra )
831 cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra )
830 cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra )
832 dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
831 dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
833
832
834 if self.online:
833 if self.online:
835 if (spc.size + cspc.size + dc.size) != self.__blocksize:
834 if (spc.size + cspc.size + dc.size) != self.__blocksize:
836 for nTries in range( self.__nTries ):
835 for nTries in range( self.__nTries ):
837 #nTries = 0
836 #nTries = 0
838 #while( nTries < self.__nTries ):
837 #while( nTries < self.__nTries ):
839 #nTries += 1
838 #nTries += 1
840 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
839 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
841 time.sleep( self.__delay )
840 time.sleep( self.__delay )
842 self.__fp.seek( fpointer )
841 self.__fp.seek( fpointer )
843 fpointer = self.__fp.tell()
842 fpointer = self.__fp.tell()
844 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra )
843 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra )
845 cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra )
844 cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra )
846 dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
845 dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
847
846
848 if (spc.size + cspc.size + dc.size) == self.__blocksize:
847 if (spc.size + cspc.size + dc.size) == self.__blocksize:
849 blockOk_flag = True
848 blockOk_flag = True
850 break
849 break
851 #if (spc.size + cspc.size + dc.size) == self.__blocksize:
850 #if (spc.size + cspc.size + dc.size) == self.__blocksize:
852 # nTries = 0
851 # nTries = 0
853 # break
852 # break
854 if not( blockOk_flag ):
853 if not( blockOk_flag ):
855 return 0
854 return 0
856 #if nTries > 0:
855 #if nTries > 0:
857 # return 0
856 # return 0
858
857
859 try:
858 try:
860 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
859 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
861 cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
860 cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
862 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
861 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
863 except:
862 except:
864 print "Data file %s is invalid" % self.filename
863 print "Data file %s is invalid" % self.filename
865 return 0
864 return 0
866
865
867 if not( self.m_ProcessingHeader.shif_fft ):
866 if not( self.m_ProcessingHeader.shif_fft ):
868 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
867 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
869 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
868 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
870
869
871 spc = numpy.transpose( spc, (0,2,1) )
870 spc = numpy.transpose( spc, (0,2,1) )
872 cspc = numpy.transpose( cspc, (0,2,1) )
871 cspc = numpy.transpose( cspc, (0,2,1) )
873 #dc = numpy.transpose(dc, (0,2,1))
872 #dc = numpy.transpose(dc, (0,2,1))
874
873
875 self.__data_spc = spc
874 self.__data_spc = spc
876 self.__data_cspc = cspc['real'] + cspc['imag']*1j
875 self.__data_cspc = cspc['real'] + cspc['imag']*1j
877 self.__data_dc = dc['real'] + dc['imag']*1j
876 self.__data_dc = dc['real'] + dc['imag']*1j
878
877
879 self.datablock_id = 0
878 self.datablock_id = 0
880 self.__flagIsNewFile = 0
879 self.__flagIsNewFile = 0
881 self.flagIsNewBlock = 1
880 self.flagIsNewBlock = 1
882
881
883 self.nReadBlocks += 1
882 self.nReadBlocks += 1
884 self.nBlocks += 1
883 self.nBlocks += 1
885
884
886 return 1
885 return 1
887
886
888
887
889 def __hasNotDataInBuffer(self):
888 def __hasNotDataInBuffer(self):
890 #if self.datablock_id >= self.m_ProcessingHeader.profilesPerBlock:
889 #if self.datablock_id >= self.m_ProcessingHeader.profilesPerBlock:
891 return 1
890 return 1
892
891
893
892
894 def __searchFilesOnLine( self, path, startDateTime=None, ext = ".pdata" ):
893 def __searchFilesOnLine( self, path, startDateTime=None, ext = ".pdata" ):
895 """
894 """
896 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
895 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
897 devuelve el archivo encontrado ademas de otros datos.
896 devuelve el archivo encontrado ademas de otros datos.
898
897
899 Input:
898 Input:
900 path : carpeta donde estan contenidos los files que contiene data
899 path : carpeta donde estan contenidos los files que contiene data
901 startDateTime : punto especifico en el tiempo del cual se requiere la data
900 startDateTime : punto especifico en el tiempo del cual se requiere la data
902 ext : extension de los files
901 ext : extension de los files
903
902
904 Return:
903 Return:
905 year : el anho
904 year : el anho
906 doy : el numero de dia del anho
905 doy : el numero de dia del anho
907 set : el set del archivo
906 set : el set del archivo
908 filename : el ultimo file de una determinada carpeta
907 filename : el ultimo file de una determinada carpeta
909 directory : eL directorio donde esta el file encontrado
908 directory : eL directorio donde esta el file encontrado
910 """
909 """
911 print "Searching files ..."
910 print "Searching files ..."
912
911
913 dirList = []
912 dirList = []
914 directory = None
913 directory = None
915
914
916 if startDateTime == None:
915 if startDateTime == None:
917 for thisPath in os.listdir(path):
916 for thisPath in os.listdir(path):
918 if os.path.isdir( os.path.join(path,thisPath) ):
917 if os.path.isdir( os.path.join(path,thisPath) ):
919 dirList.append( thisPath )
918 dirList.append( thisPath )
920
919
921 dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted
920 dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted
922 if len(dirList) > 0 :
921 if len(dirList) > 0 :
923 directory = dirList[-1] #me quedo con el ultimo directorio de una carpeta
922 directory = dirList[-1] #me quedo con el ultimo directorio de una carpeta
924 else:
923 else:
925 year = startDateTime.timetuple().tm_year
924 year = startDateTime.timetuple().tm_year
926 doy = startDateTime.timetuple().tm_yday
925 doy = startDateTime.timetuple().tm_yday
927
926
928 doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas
927 doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas
929 if os.path.isdir( os.path.join(path,doyPath) ):
928 if os.path.isdir( os.path.join(path,doyPath) ):
930 directory = doyPath
929 directory = doyPath
931
930
932 doyPath = doyPath.lower() #caso del nombre en minusculas
931 doyPath = doyPath.lower() #caso del nombre en minusculas
933 if os.path.isdir( os.path.join(path,doyPath) ):
932 if os.path.isdir( os.path.join(path,doyPath) ):
934 directory = doyPath
933 directory = doyPath
935
934
936 if directory == None:
935 if directory == None:
937 return 0, 0, 0, None, None
936 return 0, 0, 0, None, None
938
937
939 filename = getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext )
938 filename = getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext )
940
939
941 if filename == None:
940 if filename == None:
942 return 0, 0, 0, None, None
941 return 0, 0, 0, None, None
943
942
944 year = int( directory[-7:-3] )
943 year = int( directory[-7:-3] )
945 doy = int( directory[-3:] )
944 doy = int( directory[-3:] )
946 ln = len( ext )
945 ln = len( ext )
947 set = int( filename[-ln-3:-ln] )
946 set = int( filename[-ln-3:-ln] )
948
947
949 return year, doy, set, filename, directory
948 return year, doy, set, filename, directory
950
949
951
950
952 def __searchFilesOffLine( self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata" ):
951 def __searchFilesOffLine( self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata" ):
953 """
952 """
954 Realiza una busqueda de los archivos que coincidan con los parametros
953 Realiza una busqueda de los archivos que coincidan con los parametros
955 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
954 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
956 correcta la estructura de directorios debe ser la siguiente:
955 correcta la estructura de directorios debe ser la siguiente:
957
956
958 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
957 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
959
958
960 [yyyy]: anio
959 [yyyy]: anio
961 [ddd] : dia del anio
960 [ddd] : dia del anio
962 [sss] : set del archivo
961 [sss] : set del archivo
963
962
964 Inputs:
963 Inputs:
965 path : Directorio de datos donde se realizara la busqueda. Todos los
964 path : Directorio de datos donde se realizara la busqueda. Todos los
966 ficheros que concidan con el criterio de busqueda seran
965 ficheros que concidan con el criterio de busqueda seran
967 almacenados en una lista y luego retornados.
966 almacenados en una lista y luego retornados.
968 startDateTime : Fecha inicial. Rechaza todos los archivos donde
967 startDateTime : Fecha inicial. Rechaza todos los archivos donde
969 file end time < startDateTime (objeto datetime.datetime)
968 file end time < startDateTime (objeto datetime.datetime)
970
969
971 endDateTime : Fecha final. Rechaza todos los archivos donde
970 endDateTime : Fecha final. Rechaza todos los archivos donde
972 file start time > endDateTime (obejto datetime.datetime)
971 file start time > endDateTime (obejto datetime.datetime)
973
972
974 set : Set del primer archivo a leer. Por defecto None
973 set : Set del primer archivo a leer. Por defecto None
975
974
976 expLabel : Nombre del subdirectorio de datos. Por defecto ""
975 expLabel : Nombre del subdirectorio de datos. Por defecto ""
977
976
978 ext : Extension de los archivos a leer. Por defecto .r
977 ext : Extension de los archivos a leer. Por defecto .r
979
978
980 Return:
979 Return:
981
980
982 (pathList, filenameList)
981 (pathList, filenameList)
983
982
984 pathList : Lista de directorios donde se encontraron archivos dentro
983 pathList : Lista de directorios donde se encontraron archivos dentro
985 de los parametros especificados
984 de los parametros especificados
986 filenameList : Lista de archivos (ruta completa) que coincidieron con los
985 filenameList : Lista de archivos (ruta completa) que coincidieron con los
987 parametros especificados.
986 parametros especificados.
988
987
989 Variables afectadas:
988 Variables afectadas:
990
989
991 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
990 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
992 como fuente para leer los bloque de datos, si se termina
991 como fuente para leer los bloque de datos, si se termina
993 de leer todos los bloques de datos de un determinado
992 de leer todos los bloques de datos de un determinado
994 archivo se pasa al siguiente archivo de la lista.
993 archivo se pasa al siguiente archivo de la lista.
995 """
994 """
996 print "Searching files ..."
995 print "Searching files ..."
997
996
998 dirList = []
997 dirList = []
999 for thisPath in os.listdir(path):
998 for thisPath in os.listdir(path):
1000 if os.path.isdir(os.path.join(path,thisPath)):
999 if os.path.isdir(os.path.join(path,thisPath)):
1001 dirList.append(thisPath)
1000 dirList.append(thisPath)
1002
1001
1003 pathList = []
1002 pathList = []
1004
1003
1005 thisDateTime = startDateTime
1004 thisDateTime = startDateTime
1006
1005
1007 while(thisDateTime <= endDateTime):
1006 while(thisDateTime <= endDateTime):
1008 year = thisDateTime.timetuple().tm_year
1007 year = thisDateTime.timetuple().tm_year
1009 doy = thisDateTime.timetuple().tm_yday
1008 doy = thisDateTime.timetuple().tm_yday
1010
1009
1011 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
1010 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
1012 if len(match) == 0:
1011 if len(match) == 0:
1013 thisDateTime += datetime.timedelta(1)
1012 thisDateTime += datetime.timedelta(1)
1014 continue
1013 continue
1015
1014
1016 pathList.append(os.path.join(path,match[0],expLabel))
1015 pathList.append(os.path.join(path,match[0],expLabel))
1017 thisDateTime += datetime.timedelta(1)
1016 thisDateTime += datetime.timedelta(1)
1018
1017
1019 startUtSeconds = time.mktime(startDateTime.timetuple())
1018 startUtSeconds = time.mktime(startDateTime.timetuple())
1020 endUtSeconds = time.mktime(endDateTime.timetuple())
1019 endUtSeconds = time.mktime(endDateTime.timetuple())
1021
1020
1022 filenameList = []
1021 filenameList = []
1023 for thisPath in pathList:
1022 for thisPath in pathList:
1024 fileList = glob.glob1(thisPath, "*%s" %ext)
1023 fileList = glob.glob1(thisPath, "*%s" %ext)
1025 fileList.sort()
1024 fileList.sort()
1026 for file in fileList:
1025 for file in fileList:
1027 filename = os.path.join(thisPath,file)
1026 filename = os.path.join(thisPath,file)
1028 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
1027 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
1029 filenameList.append(filename)
1028 filenameList.append(filename)
1030
1029
1031 self.filenameList = filenameList
1030 self.filenameList = filenameList
1032
1031
1033 return pathList, filenameList
1032 return pathList, filenameList
1034
1033
1035
1034
1036 def __initFilesOnline( self, path, dirfilename, filename ):
1035 def __initFilesOnline( self, path, dirfilename, filename ):
1037 """
1036 """
1038 Verifica que el primer file tenga una data valida, para ello leo el 1er bloque
1037 Verifica que el primer file tenga una data valida, para ello leo el 1er bloque
1039 del file, si no es un file valido espera una cierta cantidad de tiempo a que
1038 del file, si no es un file valido espera una cierta cantidad de tiempo a que
1040 lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo
1039 lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo
1041 devuelve 0 caso contrario devuelve 1
1040 devuelve 0 caso contrario devuelve 1
1042
1041
1043 Affected:
1042 Affected:
1044 m_BasicHeader
1043 m_BasicHeader
1045
1044
1046 Return:
1045 Return:
1047 0 : file no valido para ser leido
1046 0 : file no valido para ser leido
1048 1 : file valido para ser leido
1047 1 : file valido para ser leido
1049 """
1048 """
1050 m_BasicHeader = BasicHeader()
1049 m_BasicHeader = BasicHeader()
1051
1050
1052 file = os.path.join( path, dirfilename, filename )
1051 file = os.path.join( path, dirfilename, filename )
1053
1052
1054 for nTries in range( self.__nTries+1 ):
1053 for nTries in range( self.__nTries+1 ):
1055 try:
1054 try:
1056 fp = open( file,'rb' ) #lectura binaria
1055 fp = open( file,'rb' ) #lectura binaria
1057 except:
1056 except:
1058 raise IOError, "The file %s can't be opened" %(file)
1057 raise IOError, "The file %s can't be opened" %(file)
1059
1058
1060 try:
1059 try:
1061 m_BasicHeader.read(fp)
1060 m_BasicHeader.read(fp)
1062 except:
1061 except:
1063 print "The file %s is empty" % filename
1062 print "The file %s is empty" % filename
1064
1063
1065 fp.close()
1064 fp.close()
1066
1065
1067 if m_BasicHeader.size > 24:
1066 if m_BasicHeader.size > 24:
1068 break
1067 break
1069
1068
1070 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
1069 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
1071 break
1070 break
1072
1071
1073 print '\twaiting for new block of file %s: try %02d' % ( file, nTries )
1072 print '\twaiting for new block of file %s: try %02d' % ( file, nTries )
1074 time.sleep( self.__delay)
1073 time.sleep( self.__delay)
1075
1074
1076 if m_BasicHeader.size <= 24:
1075 if m_BasicHeader.size <= 24:
1077 return 0
1076 return 0
1078
1077
1079 return 1
1078 return 1
1080
1079
1081
1080
1082 def setup( self, path, startDateTime=None, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
1081 def setup( self, path, startDateTime=None, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
1083 """
1082 """
1084 setup configura los parametros de lectura de la clase SpectraReader.
1083 setup configura los parametros de lectura de la clase SpectraReader.
1085
1084
1086 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
1085 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
1087 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
1086 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
1088 self.filenameList.
1087 self.filenameList.
1089
1088
1090 Input:
1089 Input:
1091 path : Directorios donde se ubican los datos a leer. Dentro de este
1090 path : Directorios donde se ubican los datos a leer. Dentro de este
1092 directorio deberia de estar subdirectorios de la forma:
1091 directorio deberia de estar subdirectorios de la forma:
1093
1092
1094 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
1093 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
1095
1094
1096 startDateTime : Fecha inicial. Rechaza todos los archivos donde
1095 startDateTime : Fecha inicial. Rechaza todos los archivos donde
1097 file end time < startDatetime (objeto datetime.datetime)
1096 file end time < startDatetime (objeto datetime.datetime)
1098
1097
1099 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
1098 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
1100 file end time < startDatetime (objeto datetime.datetime)
1099 file end time < startDatetime (objeto datetime.datetime)
1101
1100
1102 set : Set del primer archivo a leer. Por defecto None
1101 set : Set del primer archivo a leer. Por defecto None
1103
1102
1104 expLabel : Nombre del subdirectorio de datos. Por defecto ""
1103 expLabel : Nombre del subdirectorio de datos. Por defecto ""
1105
1104
1106 ext : Extension de los archivos a leer. Por defecto .pdata
1105 ext : Extension de los archivos a leer. Por defecto .pdata
1107
1106
1108 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
1107 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
1109
1108
1110 Return:
1109 Return:
1111 0 : Si no encuentra files que cumplan con las condiciones dadas
1110 0 : Si no encuentra files que cumplan con las condiciones dadas
1112 1 : Si encuentra files que cumplan con las condiciones dadas
1111 1 : Si encuentra files que cumplan con las condiciones dadas
1113
1112
1114 Affected:
1113 Affected:
1115 self.startUTCSeconds
1114 self.startUTCSeconds
1116 self.endUTCSeconds
1115 self.endUTCSeconds
1117 self.startYear
1116 self.startYear
1118 self.endYear
1117 self.endYear
1119 self.startDoy
1118 self.startDoy
1120 self.endDoy
1119 self.endDoy
1121 self.__pathList
1120 self.__pathList
1122 self.filenameList
1121 self.filenameList
1123 self.online
1122 self.online
1124 """
1123 """
1125 if online:
1124 if online:
1126 fileOK_flag = False
1125 fileOK_flag = False
1127 subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
1126 subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
1128 file = os.path.join( path, subfolder )
1127 file = os.path.join( path, subfolder )
1129
1128
1130 for nTries in range( self.__nTries+1 ): #espera por el 1er file
1129 for nTries in range( self.__nTries+1 ): #espera por el 1er file
1131 year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
1130 year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
1132
1131
1133 if filename != None:
1132 if filename != None:
1134 if isFileOK( os.path.join( path,dirfilename,filename ) ):
1133 if isFileOK( os.path.join( path,dirfilename,filename ) ):
1135 fileOK_flag = True
1134 fileOK_flag = True
1136 break
1135 break
1137
1136
1138 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
1137 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
1139 break
1138 break
1140
1139
1141 print "Searching first file in \"%s\", try %03d ..." % ( file, nTries+1 )
1140 print "Searching first file in \"%s\", try %03d ..." % ( file, nTries+1 )
1142 time.sleep( self.__delay )
1141 time.sleep( self.__delay )
1143
1142
1144 if not( fileOK_flag ): #filename == None:
1143 if not( fileOK_flag ): #filename == None:
1145 print "No files on line or invalid first file"
1144 print "No files on line or invalid first file"
1146 return 0
1145 return 0
1147
1146
1148 if self.__initFilesOnline( path, dirfilename, filename ) == 0:
1147 if self.__initFilesOnline( path, dirfilename, filename ) == 0:
1149 print "The file %s hasn't enough data" % filename
1148 print "The file %s hasn't enough data" % filename
1150 return 0
1149 return 0
1151
1150
1152 self.__year = year
1151 self.__year = year
1153 self.__doy = doy
1152 self.__doy = doy
1154 self.__set = set - 1
1153 self.__set = set - 1
1155 self.__path = path
1154 self.__path = path
1156
1155
1157 else:
1156 else:
1158 pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext )
1157 pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext )
1159 self.__idFile = -1
1158 self.__idFile = -1
1160 self.__pathList = pathList
1159 self.__pathList = pathList
1161 self.filenameList = filenameList
1160 self.filenameList = filenameList
1162
1161
1163 self.online = online
1162 self.online = online
1164 self.__ext = ext
1163 self.__ext = ext
1165
1164
1166 if not( self.__setNextFile() ):
1165 if not( self.__setNextFile() ):
1167 if (startDateTime != None) and (endDateTime != None):
1166 if (startDateTime != None) and (endDateTime != None):
1168 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
1167 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
1169 elif startDateTime != None:
1168 elif startDateTime != None:
1170 print "No files in : %s" % startDateTime.ctime()
1169 print "No files in : %s" % startDateTime.ctime()
1171 else:
1170 else:
1172 print "No files"
1171 print "No files"
1173 return 0
1172 return 0
1174
1173
1175 if startDateTime != None:
1174 if startDateTime != None:
1176 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
1175 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
1177 self.startYear = startDateTime.timetuple().tm_year
1176 self.startYear = startDateTime.timetuple().tm_year
1178 self.startDoy = startDateTime.timetuple().tm_yday
1177 self.startDoy = startDateTime.timetuple().tm_yday
1179
1178
1180 if endDateTime != None:
1179 if endDateTime != None:
1181 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
1180 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
1182 self.endYear = endDateTime.timetuple().tm_year
1181 self.endYear = endDateTime.timetuple().tm_year
1183 self.endDoy = endDateTime.timetuple().tm_yday
1182 self.endDoy = endDateTime.timetuple().tm_yday
1184 #call fillHeaderValues() - to Data Object
1183 #call fillHeaderValues() - to Data Object
1185
1184
1186 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
1185 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
1187 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1186 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1188 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1187 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1189 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
1188 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
1190 self.m_Spectra.dataType = self.__dataType
1189 self.m_Spectra.dataType = self.__dataType
1191
1190
1192 return 1
1191 return 1
1193
1192
1194
1193
1195 def readNextBlock( self ):
1194 def readNextBlock( self ):
1196 """
1195 """
1197 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
1196 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
1198 mas bloques disponibles en el archivo actual salta al siguiente.
1197 mas bloques disponibles en el archivo actual salta al siguiente.
1199
1198
1200 Affected:
1199 Affected:
1201 self.__lastUTTime
1200 self.__lastUTTime
1202
1201
1203 Return: None
1202 Return: None
1204 """
1203 """
1205
1204
1206 if not( self.__setNewBlock() ):
1205 if not( self.__setNewBlock() ):
1207 return 0
1206 return 0
1208
1207
1209 if not( self.__readBlock() ):
1208 if not( self.__readBlock() ):
1210 return 0
1209 return 0
1211
1210
1212 self.__lastUTTime = self.m_BasicHeader.utc
1211 self.__lastUTTime = self.m_BasicHeader.utc
1213
1212
1214 return 1
1213 return 1
1215
1214
1216
1215
1217 def getData(self):
1216 def getData(self):
1218 """
1217 """
1219 Copia el buffer de lectura a la clase "Spectra",
1218 Copia el buffer de lectura a la clase "Spectra",
1220 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1219 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1221 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
1220 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
1222
1221
1223 Return:
1222 Return:
1224 0 : Si no hay mas archivos disponibles
1223 0 : Si no hay mas archivos disponibles
1225 1 : Si hizo una buena copia del buffer
1224 1 : Si hizo una buena copia del buffer
1226
1225
1227 Affected:
1226 Affected:
1228 self.m_Spectra
1227 self.m_Spectra
1229 self.__datablockIndex
1228 self.__datablockIndex
1230 self.flagResetProcessing
1229 self.flagResetProcessing
1231 self.flagIsNewBlock
1230 self.flagIsNewBlock
1232 """
1231 """
1233
1232
1234 self.flagResetProcessing = 0
1233 self.flagResetProcessing = 0
1235 self.flagIsNewBlock = 0
1234 self.flagIsNewBlock = 0
1236
1235
1237 if self.__hasNotDataInBuffer():
1236 if self.__hasNotDataInBuffer():
1238
1237
1239 if not( self.readNextBlock() ):
1238 if not( self.readNextBlock() ):
1240 self.__setNextFile()
1239 self.__setNextFile()
1241 return 0
1240 return 0
1242
1241
1243 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
1242 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
1244 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1243 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1245 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1244 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1246 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
1245 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
1247 self.m_Spectra.heights = self.__heights
1246 self.m_Spectra.heights = self.__heights
1248 self.m_Spectra.dataType = self.__dataType
1247 self.m_Spectra.dataType = self.__dataType
1249
1248
1250 if self.noMoreFiles == 1:
1249 if self.noMoreFiles == 1:
1251 print 'Process finished'
1250 print 'Process finished'
1252 return 0
1251 return 0
1253
1252
1254 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1253 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1255
1254
1256 if self.__data_dc == None:
1255 if self.__data_dc == None:
1257 self.m_Voltage.flagNoData = True
1256 self.m_Voltage.flagNoData = True
1258 return 0
1257 return 0
1259
1258
1260 self.m_Spectra.flagNoData = False
1259 self.m_Spectra.flagNoData = False
1261 self.m_Spectra.flagResetProcessing = self.flagResetProcessing
1260 self.m_Spectra.flagResetProcessing = self.flagResetProcessing
1262
1261
1263 self.m_Spectra.data_spc = self.__data_spc
1262 self.m_Spectra.data_spc = self.__data_spc
1264 self.m_Spectra.data_cspc = self.__data_cspc
1263 self.m_Spectra.data_cspc = self.__data_cspc
1265 self.m_Spectra.data_dc = self.__data_dc
1264 self.m_Spectra.data_dc = self.__data_dc
1266
1265
1267 #call setData - to Data Object
1266 #call setData - to Data Object
1268 #self.datablock_id += 1
1267 #self.datablock_id += 1
1269 #self.idProfile += 1
1268 #self.idProfile += 1
1270
1269
1271 return 1
1270 return 1
1272
1271
1273
1272 class SpectraWriter( JRODataWriter ):
1274 class SpectraWriter(DataWriter):
1275 """
1273 """
1276 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
1274 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
1277 de los datos siempre se realiza por bloques.
1275 de los datos siempre se realiza por bloques.
1278 """
1276 """
1279
1277
1280 def __init__(self,m_Spectra=None):
1278 def __init__(self,m_Spectra=None):
1281 """
1279 """
1282 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
1280 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
1283
1281
1284 Affected:
1282 Affected:
1285 self.m_Spectra
1283 self.m_Spectra
1286 self.m_BasicHeader
1284 self.m_BasicHeader
1287 self.m_SystemHeader
1285 self.m_SystemHeader
1288 self.m_RadarControllerHeader
1286 self.m_RadarControllerHeader
1289 self.m_ProcessingHeader
1287 self.m_ProcessingHeader
1290
1288
1291 Return: None
1289 Return: None
1292 """
1290 """
1293
1291
1294 if m_Spectra == None:
1292 if m_Spectra == None:
1295 m_Spectra = Spectra()
1293 m_Spectra = Spectra()
1296
1294
1297 self.m_Spectra = m_Spectra
1295 self.m_Spectra = m_Spectra
1298
1296
1299 self.__path = None
1297 self.__path = None
1300
1298
1301 self.__fp = None
1299 self.__fp = None
1302
1300
1303 self.__format = None
1301 self.__format = None
1304
1302
1305 self.__blocksCounter = 0
1303 self.__blocksCounter = 0
1306
1304
1307 self.__setFile = None
1305 self.__setFile = None
1308
1306
1309 self.__flagIsNewFile = 1
1307 self.__flagIsNewFile = 1
1310
1308
1311 self.__dataType = None
1309 self.__dataType = None
1312
1310
1313 self.__ext = None
1311 self.__ext = None
1314
1312
1315 self.__shape_spc_Buffer = None
1313 self.__shape_spc_Buffer = None
1316 self.__shape_cspc_Buffer = None
1314 self.__shape_cspc_Buffer = None
1317 self.__shape_dc_Buffer = None
1315 self.__shape_dc_Buffer = None
1318
1316
1319 self.nWriteBlocks = 0
1317 self.nWriteBlocks = 0
1320
1318
1321 self.flagIsNewBlock = 0
1319 self.flagIsNewBlock = 0
1322
1320
1323 self.noMoreFiles = 0
1321 self.noMoreFiles = 0
1324
1322
1325 self.filename = None
1323 self.filename = None
1326
1324
1327 self.m_BasicHeader= BasicHeader()
1325 self.m_BasicHeader= BasicHeader()
1328
1326
1329 self.m_SystemHeader = SystemHeader()
1327 self.m_SystemHeader = SystemHeader()
1330
1328
1331 self.m_RadarControllerHeader = RadarControllerHeader()
1329 self.m_RadarControllerHeader = RadarControllerHeader()
1332
1330
1333 self.m_ProcessingHeader = ProcessingHeader()
1331 self.m_ProcessingHeader = ProcessingHeader()
1334
1332
1335 self.__data_spc = None
1333 self.__data_spc = None
1336 self.__data_cspc = None
1334 self.__data_cspc = None
1337 self.__data_dc = None
1335 self.__data_dc = None
1338
1336
1339 def __writeFirstHeader(self):
1337 def __writeFirstHeader(self):
1340 """
1338 """
1341 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1339 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1342
1340
1343 Affected:
1341 Affected:
1344 __dataType
1342 __dataType
1345
1343
1346 Return:
1344 Return:
1347 None
1345 None
1348 """
1346 """
1349 self.__writeBasicHeader()
1347 self.__writeBasicHeader()
1350 self.__wrSystemHeader()
1348 self.__wrSystemHeader()
1351 self.__wrRadarControllerHeader()
1349 self.__wrRadarControllerHeader()
1352 self.__wrProcessingHeader()
1350 self.__wrProcessingHeader()
1353 self.__dataType = self.m_Spectra.dataType
1351 self.__dataType = self.m_Spectra.dataType
1354
1352
1355
1353
1356 def __writeBasicHeader(self, fp=None):
1354 def __writeBasicHeader(self, fp=None):
1357 """
1355 """
1358 Escribe solo el Basic header en el file creado
1356 Escribe solo el Basic header en el file creado
1359
1357
1360 Return:
1358 Return:
1361 None
1359 None
1362 """
1360 """
1363 if fp == None:
1361 if fp == None:
1364 fp = self.__fp
1362 fp = self.__fp
1365
1363
1366 self.m_BasicHeader.write(fp)
1364 self.m_BasicHeader.write(fp)
1367
1365
1368
1366
1369 def __wrSystemHeader(self,fp=None):
1367 def __wrSystemHeader(self,fp=None):
1370 """
1368 """
1371 Escribe solo el System header en el file creado
1369 Escribe solo el System header en el file creado
1372
1370
1373 Return:
1371 Return:
1374 None
1372 None
1375 """
1373 """
1376 if fp == None:
1374 if fp == None:
1377 fp = self.__fp
1375 fp = self.__fp
1378
1376
1379 self.m_SystemHeader.write(fp)
1377 self.m_SystemHeader.write(fp)
1380
1378
1381
1379
1382 def __wrRadarControllerHeader(self,fp=None):
1380 def __wrRadarControllerHeader(self,fp=None):
1383 """
1381 """
1384 Escribe solo el RadarController header en el file creado
1382 Escribe solo el RadarController header en el file creado
1385
1383
1386 Return:
1384 Return:
1387 None
1385 None
1388 """
1386 """
1389 if fp == None:
1387 if fp == None:
1390 fp = self.__fp
1388 fp = self.__fp
1391
1389
1392 self.m_RadarControllerHeader.write(fp)
1390 self.m_RadarControllerHeader.write(fp)
1393
1391
1394
1392
1395 def __wrProcessingHeader(self,fp=None):
1393 def __wrProcessingHeader(self,fp=None):
1396 """
1394 """
1397 Escribe solo el Processing header en el file creado
1395 Escribe solo el Processing header en el file creado
1398
1396
1399 Return:
1397 Return:
1400 None
1398 None
1401 """
1399 """
1402 if fp == None:
1400 if fp == None:
1403 fp = self.__fp
1401 fp = self.__fp
1404
1402
1405 self.m_ProcessingHeader.write(fp)
1403 self.m_ProcessingHeader.write(fp)
1406
1404
1407
1405
1408 def __setNextFile(self):
1406 def __setNextFile(self):
1409 """
1407 """
1410 Determina el siguiente file que sera escrito
1408 Determina el siguiente file que sera escrito
1411
1409
1412 Affected:
1410 Affected:
1413 self.filename
1411 self.filename
1414 self.__subfolder
1412 self.__subfolder
1415 self.__fp
1413 self.__fp
1416 self.__setFile
1414 self.__setFile
1417 self.__flagIsNewFile
1415 self.__flagIsNewFile
1418
1416
1419 Return:
1417 Return:
1420 0 : Si el archivo no puede ser escrito
1418 0 : Si el archivo no puede ser escrito
1421 1 : Si el archivo esta listo para ser escrito
1419 1 : Si el archivo esta listo para ser escrito
1422 """
1420 """
1423 ext = self.__ext
1421 ext = self.__ext
1424 path = self.__path
1422 path = self.__path
1425
1423
1426 if self.__fp != None:
1424 if self.__fp != None:
1427 self.__fp.close()
1425 self.__fp.close()
1428
1426
1429 #if self.m_BasicHeader.size <= 24: return 0 #no existe la suficiente data para ser escrita
1427 #if self.m_BasicHeader.size <= 24: return 0 #no existe la suficiente data para ser escrita
1430
1428
1431 timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
1429 timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
1432 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1430 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1433
1431
1434 tmp = os.path.join( path, subfolder )
1432 tmp = os.path.join( path, subfolder )
1435 if not( os.path.exists(tmp) ):
1433 if not( os.path.exists(tmp) ):
1436 os.mkdir(tmp)
1434 os.mkdir(tmp)
1437 self.__setFile = -1 #inicializo mi contador de seteo
1435 self.__setFile = -1 #inicializo mi contador de seteo
1438 else:
1436 else:
1439 filesList = os.listdir( tmp )
1437 filesList = os.listdir( tmp )
1440 if len( filesList ) > 0:
1438 if len( filesList ) > 0:
1441 filesList = sorted( filesList, key=str.lower )
1439 filesList = sorted( filesList, key=str.lower )
1442 filen = filesList[-1]
1440 filen = filesList[-1]
1443 # el filename debera tener el siguiente formato
1441 # el filename debera tener el siguiente formato
1444 # 0 1234 567 89A BCDE (hex)
1442 # 0 1234 567 89A BCDE (hex)
1445 # P YYYY DDD SSS .ext
1443 # P YYYY DDD SSS .ext
1446 if isNumber( filen[8:11] ):
1444 if isNumber( filen[8:11] ):
1447 self.__setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1445 self.__setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1448 else:
1446 else:
1449 self.__setFile = -1
1447 self.__setFile = -1
1450 else:
1448 else:
1451 self.__setFile = -1 #inicializo mi contador de seteo
1449 self.__setFile = -1 #inicializo mi contador de seteo
1452
1450
1453 setFile = self.__setFile
1451 setFile = self.__setFile
1454 setFile += 1
1452 setFile += 1
1455 file = 'P%4.4d%3.3d%3.3d%s' % ( timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
1453 file = 'P%4.4d%3.3d%3.3d%s' % ( timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
1456
1454
1457 filename = os.path.join( path, subfolder, file )
1455 filename = os.path.join( path, subfolder, file )
1458
1456
1459 fp = open(filename,'wb')
1457 fp = open(filename,'wb')
1460
1458
1461 self.__blocksCounter = 0
1459 self.__blocksCounter = 0
1462
1460
1463 #guardando atributos
1461 #guardando atributos
1464 self.filename = filename
1462 self.filename = filename
1465 self.__subfolder = subfolder
1463 self.__subfolder = subfolder
1466 self.__fp = fp
1464 self.__fp = fp
1467 self.__setFile = setFile
1465 self.__setFile = setFile
1468 self.__flagIsNewFile = 1
1466 self.__flagIsNewFile = 1
1469
1467
1470 print 'Writing the file: %s'%self.filename
1468 print 'Writing the file: %s'%self.filename
1471
1469
1472 self.__writeFirstHeader()
1470 self.__writeFirstHeader()
1473
1471
1474 return 1
1472 return 1
1475
1473
1476
1474
1477 def __setNewBlock(self):
1475 def __setNewBlock(self):
1478 """
1476 """
1479 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1477 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1480
1478
1481 Return:
1479 Return:
1482 0 : si no pudo escribir nada
1480 0 : si no pudo escribir nada
1483 1 : Si escribio el Basic el First Header
1481 1 : Si escribio el Basic el First Header
1484 """
1482 """
1485 if self.__fp == None:
1483 if self.__fp == None:
1486 self.__setNextFile()
1484 self.__setNextFile()
1487
1485
1488 if self.__flagIsNewFile:
1486 if self.__flagIsNewFile:
1489 return 1
1487 return 1
1490
1488
1491 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1489 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1492 self.__writeBasicHeader()
1490 self.__writeBasicHeader()
1493 return 1
1491 return 1
1494
1492
1495 if not( self.__setNextFile() ):
1493 if not( self.__setNextFile() ):
1496 return 0
1494 return 0
1497
1495
1498 return 1
1496 return 1
1499
1497
1500
1498
1501 def __writeBlock(self):
1499 def __writeBlock(self):
1502 """
1500 """
1503 Escribe el buffer en el file designado
1501 Escribe el buffer en el file designado
1504
1502
1505 Affected:
1503 Affected:
1506 self.__data_spc
1504 self.__data_spc
1507 self.__data_cspc
1505 self.__data_cspc
1508 self.__data_dc
1506 self.__data_dc
1509 self.__flagIsNewFile
1507 self.__flagIsNewFile
1510 self.flagIsNewBlock
1508 self.flagIsNewBlock
1511 self.nWriteBlocks
1509 self.nWriteBlocks
1512 self.__blocksCounter
1510 self.__blocksCounter
1513
1511
1514 Return: None
1512 Return: None
1515 """
1513 """
1516 spc = numpy.transpose( self.__data_spc, (0,2,1) )
1514 spc = numpy.transpose( self.__data_spc, (0,2,1) )
1517 if not( self.m_ProcessingHeader.shif_fft ):
1515 if not( self.m_ProcessingHeader.shif_fft ):
1518 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
1516 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
1519 data = spc.reshape((-1))
1517 data = spc.reshape((-1))
1520 data.tofile(self.__fp)
1518 data.tofile(self.__fp)
1521
1519
1522 data = numpy.zeros( self.__shape_cspc_Buffer, self.__dataType )
1520 data = numpy.zeros( self.__shape_cspc_Buffer, self.__dataType )
1523 cspc = numpy.transpose( self.__data_cspc, (0,2,1) )
1521 cspc = numpy.transpose( self.__data_cspc, (0,2,1) )
1524 if not( self.m_ProcessingHeader.shif_fft ):
1522 if not( self.m_ProcessingHeader.shif_fft ):
1525 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
1523 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
1526 data['real'] = cspc.real
1524 data['real'] = cspc.real
1527 data['imag'] = cspc.imag
1525 data['imag'] = cspc.imag
1528 data = data.reshape((-1))
1526 data = data.reshape((-1))
1529 data.tofile(self.__fp)
1527 data.tofile(self.__fp)
1530
1528
1531 data = numpy.zeros( self.__shape_dc_Buffer, self.__dataType )
1529 data = numpy.zeros( self.__shape_dc_Buffer, self.__dataType )
1532 dc = self.__data_dc
1530 dc = self.__data_dc
1533 data['real'] = dc.real
1531 data['real'] = dc.real
1534 data['imag'] = dc.imag
1532 data['imag'] = dc.imag
1535 data = data.reshape((-1))
1533 data = data.reshape((-1))
1536 data.tofile(self.__fp)
1534 data.tofile(self.__fp)
1537
1535
1538 self.__data_spc.fill(0)
1536 self.__data_spc.fill(0)
1539 self.__data_cspc.fill(0)
1537 self.__data_cspc.fill(0)
1540 self.__data_dc.fill(0)
1538 self.__data_dc.fill(0)
1541
1539
1542 self.__flagIsNewFile = 0
1540 self.__flagIsNewFile = 0
1543 self.flagIsNewBlock = 1
1541 self.flagIsNewBlock = 1
1544 self.nWriteBlocks += 1
1542 self.nWriteBlocks += 1
1545 self.__blocksCounter += 1
1543 self.__blocksCounter += 1
1546
1544
1547
1545
1548 def writeNextBlock(self):
1546 def writeNextBlock(self):
1549 """
1547 """
1550 Selecciona el bloque siguiente de datos y los escribe en un file
1548 Selecciona el bloque siguiente de datos y los escribe en un file
1551
1549
1552 Return:
1550 Return:
1553 0 : Si no hizo pudo escribir el bloque de datos
1551 0 : Si no hizo pudo escribir el bloque de datos
1554 1 : Si no pudo escribir el bloque de datos
1552 1 : Si no pudo escribir el bloque de datos
1555 """
1553 """
1556 if not( self.__setNewBlock() ):
1554 if not( self.__setNewBlock() ):
1557 return 0
1555 return 0
1558
1556
1559 self.__writeBlock()
1557 self.__writeBlock()
1560 return 1
1558 return 1
1561
1559
1562
1560
1563 def __hasAllDataInBuffer(self):
1561 def __hasAllDataInBuffer(self):
1564 return 1
1562 return 1
1565
1563
1566
1564
1567 def putData(self):
1565 def putData(self):
1568 """
1566 """
1569 Setea un bloque de datos y luego los escribe en un file
1567 Setea un bloque de datos y luego los escribe en un file
1570
1568
1571 Affected:
1569 Affected:
1572 self.__data_spc
1570 self.__data_spc
1573 self.__data_cspc
1571 self.__data_cspc
1574 self.__data_dc
1572 self.__data_dc
1575
1573
1576 Return:
1574 Return:
1577 0 : Si no hay data o no hay mas files que puedan escribirse
1575 0 : Si no hay data o no hay mas files que puedan escribirse
1578 1 : Si se escribio la data de un bloque en un file
1576 1 : Si se escribio la data de un bloque en un file
1579 """
1577 """
1580 self.flagIsNewBlock = 0
1578 self.flagIsNewBlock = 0
1581
1579
1582 if self.m_Spectra.flagNoData:
1580 if self.m_Spectra.flagNoData:
1583 return 0
1581 return 0
1584
1582
1585 if self.m_Spectra.flagResetProcessing:
1583 if self.m_Spectra.flagResetProcessing:
1586 self.__data_spc.fill(0)
1584 self.__data_spc.fill(0)
1587 self.__data_cspc.fill(0)
1585 self.__data_cspc.fill(0)
1588 self.__data_dc.fill(0)
1586 self.__data_dc.fill(0)
1589 self.__setNextFile()
1587 self.__setNextFile()
1590
1588
1591 self.__data_spc = self.m_Spectra.data_spc
1589 self.__data_spc = self.m_Spectra.data_spc
1592 self.__data_cspc = self.m_Spectra.data_cspc
1590 self.__data_cspc = self.m_Spectra.data_cspc
1593 self.__data_dc = self.m_Spectra.data_dc
1591 self.__data_dc = self.m_Spectra.data_dc
1594
1592
1595 if True:
1593 if True:
1596 self.__getHeader()
1594 self.__getHeader()
1597 self.writeNextBlock()
1595 self.writeNextBlock()
1598
1596
1599 if self.noMoreFiles:
1597 if self.noMoreFiles:
1600 #print 'Process finished'
1598 #print 'Process finished'
1601 return 0
1599 return 0
1602
1600
1603 return 1
1601 return 1
1604
1602
1605 def __getHeader(self):
1603 def __getHeader(self):
1606 """
1604 """
1607 Obtiene una copia del First Header
1605 Obtiene una copia del First Header
1608
1606
1609 Affected:
1607 Affected:
1610 self.m_BasicHeader
1608 self.m_BasicHeader
1611 self.m_SystemHeader
1609 self.m_SystemHeader
1612 self.m_RadarControllerHeader
1610 self.m_RadarControllerHeader
1613 self.m_ProcessingHeader
1611 self.m_ProcessingHeader
1614 self.__dataType
1612 self.__dataType
1615
1613
1616 Return:
1614 Return:
1617 None
1615 None
1618 """
1616 """
1619 self.m_BasicHeader = self.m_Spectra.m_BasicHeader.copy()
1617 self.m_BasicHeader = self.m_Spectra.m_BasicHeader.copy()
1620 self.m_SystemHeader = self.m_Spectra.m_SystemHeader.copy()
1618 self.m_SystemHeader = self.m_Spectra.m_SystemHeader.copy()
1621 self.m_RadarControllerHeader = self.m_Spectra.m_RadarControllerHeader.copy()
1619 self.m_RadarControllerHeader = self.m_Spectra.m_RadarControllerHeader.copy()
1622 self.m_ProcessingHeader = self.m_Spectra.m_ProcessingHeader.copy()
1620 self.m_ProcessingHeader = self.m_Spectra.m_ProcessingHeader.copy()
1623 self.__dataType = self.m_Spectra.dataType
1621 self.__dataType = self.m_Spectra.dataType
1624
1622
1625
1623
1626 def __setHeaderByFile(self):
1624 def __setHeaderByFile(self):
1627
1625
1628 format = self.__format
1626 format = self.__format
1629 header = ['Basic','System','RadarController','Processing']
1627 header = ['Basic','System','RadarController','Processing']
1630
1628
1631 fmtFromFile = None
1629 fmtFromFile = None
1632 headerFromFile = None
1630 headerFromFile = None
1633
1631
1634
1632
1635 fileTable = self.__configHeaderFile
1633 fileTable = self.__configHeaderFile
1636
1634
1637 if os.access(fileTable, os.R_OK):
1635 if os.access(fileTable, os.R_OK):
1638 import re, string
1636 import re, string
1639
1637
1640 f = open(fileTable,'r')
1638 f = open(fileTable,'r')
1641 lines = f.read()
1639 lines = f.read()
1642 f.close()
1640 f.close()
1643
1641
1644 #Delete comments into expConfig
1642 #Delete comments into expConfig
1645 while 1:
1643 while 1:
1646
1644
1647 startComment = string.find(lines.lower(),'#')
1645 startComment = string.find(lines.lower(),'#')
1648 if startComment == -1:
1646 if startComment == -1:
1649 break
1647 break
1650 endComment = string.find(lines.lower(),'\n',startComment)
1648 endComment = string.find(lines.lower(),'\n',startComment)
1651 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
1649 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
1652
1650
1653 while expFromFile == None:
1651 while expFromFile == None:
1654
1652
1655 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
1653 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
1656 nextFmt = string.find(lines.lower(),'format',currFmt+10)
1654 nextFmt = string.find(lines.lower(),'format',currFmt+10)
1657
1655
1658 if currFmt == -1:
1656 if currFmt == -1:
1659 break
1657 break
1660 if nextFmt == -1:
1658 if nextFmt == -1:
1661 nextFmt = len(lines)-1
1659 nextFmt = len(lines)-1
1662
1660
1663 fmtTable = lines[currFmt:nextFmt]
1661 fmtTable = lines[currFmt:nextFmt]
1664 lines = lines[nextFmt:]
1662 lines = lines[nextFmt:]
1665
1663
1666 fmtRead = self.__getValueFromArg(fmtTable,'format')
1664 fmtRead = self.__getValueFromArg(fmtTable,'format')
1667 if fmtRead != format:
1665 if fmtRead != format:
1668 continue
1666 continue
1669 fmtFromFile = fmtRead
1667 fmtFromFile = fmtRead
1670
1668
1671 lines2 = fmtTable
1669 lines2 = fmtTable
1672
1670
1673 while headerFromFile == None:
1671 while headerFromFile == None:
1674
1672
1675 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
1673 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
1676 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
1674 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
1677
1675
1678 if currHeader == -1:
1676 if currHeader == -1:
1679 break
1677 break
1680 if nextHeader == -1:
1678 if nextHeader == -1:
1681 nextHeader = len(lines2)-1
1679 nextHeader = len(lines2)-1
1682
1680
1683 headerTable = lines2[currHeader:nextHeader]
1681 headerTable = lines2[currHeader:nextHeader]
1684 lines2 = lines2[nextHeader:]
1682 lines2 = lines2[nextHeader:]
1685
1683
1686 headerRead = self.__getValueFromArg(headerTable,'site')
1684 headerRead = self.__getValueFromArg(headerTable,'site')
1687 if not(headerRead in header):
1685 if not(headerRead in header):
1688 continue
1686 continue
1689 headerFromFile = headerRead
1687 headerFromFile = headerRead
1690
1688
1691 if headerRead == 'Basic':
1689 if headerRead == 'Basic':
1692 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
1690 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
1693 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
1691 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
1694 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
1692 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
1695 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
1693 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
1696 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
1694 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
1697 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
1695 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
1698 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
1696 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
1699 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
1697 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
1700
1698
1701 else:
1699 else:
1702 print "file access denied:%s"%fileTable
1700 print "file access denied:%s"%fileTable
1703 sys.exit(0)
1701 sys.exit(0)
1704
1702
1705
1703
1706 def setup(self,path,format='pdata'):
1704 def setup(self,path,format='pdata'):
1707 """
1705 """
1708 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1706 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1709
1707
1710 Inputs:
1708 Inputs:
1711 path : el path destino en el cual se escribiran los files a crear
1709 path : el path destino en el cual se escribiran los files a crear
1712 format : formato en el cual sera salvado un file
1710 format : formato en el cual sera salvado un file
1713
1711
1714 Return:
1712 Return:
1715 0 : Si no realizo un buen seteo
1713 0 : Si no realizo un buen seteo
1716 1 : Si realizo un buen seteo
1714 1 : Si realizo un buen seteo
1717 """
1715 """
1718 if format == 'hdf5':
1716 if format == 'hdf5':
1719 ext = '.hdf5'
1717 ext = '.hdf5'
1720 format = 'hdf5'
1718 format = 'hdf5'
1721 print 'call hdf5 library'
1719 print 'call hdf5 library'
1722 return 0
1720 return 0
1723
1721
1724 if format == 'rawdata':
1722 if format == 'rawdata':
1725 ext = '.r'
1723 ext = '.r'
1726 format = 'Jicamarca'
1724 format = 'Jicamarca'
1727
1725
1728 if format == 'pdata':
1726 if format == 'pdata':
1729 ext = '.pdata'
1727 ext = '.pdata'
1730 format = 'pdata'
1728 format = 'pdata'
1731
1729
1732 #call to config_headers
1730 #call to config_headers
1733 #self.__setHeaderByFile()
1731 #self.__setHeaderByFile()
1734
1732
1735 self.__path = path
1733 self.__path = path
1736 self.__setFile = -1
1734 self.__setFile = -1
1737 self.__ext = ext
1735 self.__ext = ext
1738 self.__format = format
1736 self.__format = format
1739
1737
1740 self.__getHeader()
1738 self.__getHeader()
1741
1739
1742 self.__shape_spc_Buffer = ( self.m_Spectra.nChannels,
1740 self.__shape_spc_Buffer = ( self.m_Spectra.nChannels,
1743 self.m_ProcessingHeader.numHeights,
1741 self.m_ProcessingHeader.numHeights,
1744 self.m_ProcessingHeader.profilesPerBlock
1742 self.m_ProcessingHeader.profilesPerBlock
1745 )
1743 )
1746
1744
1747 self.__shape_cspc_Buffer = ( self.m_Spectra.nPairs,
1745 self.__shape_cspc_Buffer = ( self.m_Spectra.nPairs,
1748 self.m_ProcessingHeader.numHeights,
1746 self.m_ProcessingHeader.numHeights,
1749 self.m_ProcessingHeader.profilesPerBlock
1747 self.m_ProcessingHeader.profilesPerBlock
1750 )
1748 )
1751
1749
1752 self.__shape_dc_Buffer = ( self.m_SystemHeader.numChannels,
1750 self.__shape_dc_Buffer = ( self.m_SystemHeader.numChannels,
1753 self.m_ProcessingHeader.numHeights
1751 self.m_ProcessingHeader.numHeights
1754 )
1752 )
1755
1753
1756 if not( self.__setNextFile() ):
1754 if not( self.__setNextFile() ):
1757 print "There isn't a next file" #"zzzzzzzzzzzz"
1755 print "There isn't a next file" #"zzzzzzzzzzzz"
1758 return 0
1756 return 0
1759
1757
1760 return 1 No newline at end of file
1758 return 1
Show file before | Show file after | Hide comments
@@ -1,1634 +1,1631
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 IO.HeaderIO import *
17 from Model.JROHeader import *
18 from IO.DataIO import DataReader
19 from IO.DataIO import DataWriter
20
21 from Model.Voltage import Voltage
18 from Model.Voltage import Voltage
22
19
20 from IO.DataIO import JRODataReader
21 from IO.DataIO import JRODataWriter
23
22
24 def isFileOK(filename):
23 def isFileOK(filename):
25 """
24 """
26 Determina si la cabecera de un archivo es valido o no, si lo es entonces seria un archivo que podria contener data,
25 Determina si la cabecera de un archivo es valido o no, si lo es entonces seria un archivo que podria contener data,
27 si no seria un archivo invalido
26 si no seria un archivo invalido
28
27
29 Return:
28 Return:
30 True : si es un archivo valido
29 True : si es un archivo valido
31 False : si no es un archivo valido
30 False : si no es un archivo valido
32
31
33 Exceptions:
32 Exceptions:
34 Si al leer la cabecera esta no coincide con el tipo de las variables que la contienen entonces se dispara
33 Si al leer la cabecera esta no coincide con el tipo de las variables que la contienen entonces se dispara
35 una exception
34 una exception
36 """
35 """
37 m_BasicHeader = BasicHeader()
36 m_BasicHeader = BasicHeader()
38 m_ProcessingHeader = ProcessingHeader()
37 m_ProcessingHeader = ProcessingHeader()
39 m_RadarControllerHeader = RadarControllerHeader()
38 m_RadarControllerHeader = RadarControllerHeader()
40 m_SystemHeader = SystemHeader()
39 m_SystemHeader = SystemHeader()
41 fp = None
40 fp = None
42
41
43 try:
42 try:
44 fp = open( filename,'rb' ) #lectura binaria
43 fp = open( filename,'rb' ) #lectura binaria
45 m_BasicHeader.read(fp)
44 m_BasicHeader.read(fp)
46 m_SystemHeader.read(fp)
45 m_SystemHeader.read(fp)
47 m_RadarControllerHeader.read(fp)
46 m_RadarControllerHeader.read(fp)
48 m_ProcessingHeader.read(fp)
47 m_ProcessingHeader.read(fp)
49 fp.close()
48 fp.close()
50 except:
49 except:
51 if fp != None: fp.close()
50 if fp != None: fp.close()
52 return False
51 return False
53
52
54 return True
53 return True
55
54
56
55
57 def getlastFileFromPath(pathList,ext):
56 def getlastFileFromPath(pathList,ext):
58 """
57 """
59 Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
58 Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
60 al final de la depuracion devuelve el ultimo file de la lista que quedo.
59 al final de la depuracion devuelve el ultimo file de la lista que quedo.
61
60
62 Input:
61 Input:
63 pathList : lista conteniendo todos los filename completos que componen una determinada carpeta
62 pathList : lista conteniendo todos los filename completos que componen una determinada carpeta
64 ext : extension de los files contenidos en una carpeta
63 ext : extension de los files contenidos en una carpeta
65
64
66 Return:
65 Return:
67 El ultimo file de una determinada carpeta
66 El ultimo file de una determinada carpeta
68 """
67 """
69
68
70 filesList = []
69 filesList = []
71 filename = None
70 filename = None
72
71
73 # 0 1234 567 89A BCDE
72 # 0 1234 567 89A BCDE
74 # D YYYY DDD SSS .ext
73 # D YYYY DDD SSS .ext
75
74
76 for filename in pathList:
75 for filename in pathList:
77 year = filename[1:5]
76 year = filename[1:5]
78 doy = filename[5:8]
77 doy = filename[5:8]
79 leng = len( ext )
78 leng = len( ext )
80
79
81 if ( filename[-leng:].upper() != ext.upper() ) : continue
80 if ( filename[-leng:].upper() != ext.upper() ) : continue
82 if not( isNumber( year ) ) : continue
81 if not( isNumber( year ) ) : continue
83 if not( isNumber( doy ) ) : continue
82 if not( isNumber( doy ) ) : continue
84
83
85 filesList.append(filename)
84 filesList.append(filename)
86
85
87 if len( filesList ) > 0:
86 if len( filesList ) > 0:
88 filesList = sorted( filesList, key=str.lower )
87 filesList = sorted( filesList, key=str.lower )
89 filename = filesList[-1]
88 filename = filesList[-1]
90
89
91 return filename
90 return filename
92
91
93
92
94 def checkForRealPath(path,year,doy,set,ext):
93 def checkForRealPath(path,year,doy,set,ext):
95 """
94 """
96 Por ser Linux Case Sensitive la funcion checkForRealPath encuentra el nombre correcto de un path,
95 Por ser Linux Case Sensitive la funcion checkForRealPath encuentra el nombre correcto de un path,
97 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
96 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
98 el path exacto de un determinado file.
97 el path exacto de un determinado file.
99
98
100 Example :
99 Example :
101 nombre correcto del file es ../RAWDATA/D2009307/P2009307367
100 nombre correcto del file es ../RAWDATA/D2009307/P2009307367
102
101
103 Entonces la funcion prueba con las siguientes combinaciones
102 Entonces la funcion prueba con las siguientes combinaciones
104 ../.../d2009307/d2009307367
103 ../.../d2009307/d2009307367
105 ../.../d2009307/D2009307367
104 ../.../d2009307/D2009307367
106 ../.../D2009307/d2009307367
105 ../.../D2009307/d2009307367
107 ../.../D2009307/D2009307367
106 ../.../D2009307/D2009307367
108 siendo para este caso, la ultima combinacion de letras, identica al file buscado
107 siendo para este caso, la ultima combinacion de letras, identica al file buscado
109
108
110 Return:
109 Return:
111 Si encuentra la combinacion adecuada devuelve el path completo y el nombre del file
110 Si encuentra la combinacion adecuada devuelve el path completo y el nombre del file
112 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
111 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
113 para el filename
112 para el filename
114 """
113 """
115 filepath = None
114 filepath = None
116 find_flag = False
115 find_flag = False
117 filename = None
116 filename = None
118
117
119 for dir in "dD": #barrido por las dos combinaciones posibles de "D"
118 for dir in "dD": #barrido por las dos combinaciones posibles de "D"
120 for fil in "dD": #barrido por las dos combinaciones posibles de "D"
119 for fil in "dD": #barrido por las dos combinaciones posibles de "D"
121 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
120 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
122 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext (p=d o p=D)
121 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext (p=d o p=D)
123 filepath = os.path.join( path, doypath, filename ) #formo el path completo
122 filepath = os.path.join( path, doypath, filename ) #formo el path completo
124 if os.path.exists( filepath ): #verifico que exista
123 if os.path.exists( filepath ): #verifico que exista
125 find_flag = True
124 find_flag = True
126 break
125 break
127 if find_flag:
126 if find_flag:
128 break
127 break
129
128
130 if not(find_flag):
129 if not(find_flag):
131 return None, filename
130 return None, filename
132
131
133 return filepath, filename
132 return filepath, filename
134
133
135
134
136 def isNumber(str):
135 def isNumber(str):
137 """
136 """
138 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
137 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
139
138
140 Excepciones:
139 Excepciones:
141 Si un determinado string no puede ser convertido a numero
140 Si un determinado string no puede ser convertido a numero
142 Input:
141 Input:
143 str, string al cual se le analiza para determinar si convertible a un numero o no
142 str, string al cual se le analiza para determinar si convertible a un numero o no
144
143
145 Return:
144 Return:
146 True : si el string es uno numerico
145 True : si el string es uno numerico
147 False : no es un string numerico
146 False : no es un string numerico
148 """
147 """
149 try:
148 try:
150 float( str )
149 float( str )
151 return True
150 return True
152 except:
151 except:
153 return False
152 return False
154
153
155
154
156 def isThisFileinRange(filename,startUTSeconds,endUTSeconds):
155 def isThisFileinRange(filename,startUTSeconds,endUTSeconds):
157 """
156 """
158 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
157 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
159 o no dentro del rango de fecha especificado.
158 o no dentro del rango de fecha especificado.
160
159
161 Inputs:
160 Inputs:
162 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
161 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
163
162
164 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
163 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
165 segundos contados desde 01/01/1970.
164 segundos contados desde 01/01/1970.
166 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
165 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
167 segundos contados desde 01/01/1970.
166 segundos contados desde 01/01/1970.
168
167
169 Return:
168 Return:
170 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
169 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
171 fecha especificado, de lo contrario retorna False.
170 fecha especificado, de lo contrario retorna False.
172
171
173 Excepciones:
172 Excepciones:
174 Si el archivo no existe o no puede ser abierto
173 Si el archivo no existe o no puede ser abierto
175 Si la cabecera no puede ser leida.
174 Si la cabecera no puede ser leida.
176
175
177 """
176 """
178 m_BasicHeader = BasicHeader()
177 m_BasicHeader = BasicHeader()
179
178
180 try:
179 try:
181 fp = open(filename,'rb')
180 fp = open(filename,'rb')
182 except:
181 except:
183 raise IOError, "The file %s can't be opened" %(filename)
182 raise IOError, "The file %s can't be opened" %(filename)
184
183
185 if not(m_BasicHeader.read(fp)):
184 if not(m_BasicHeader.read(fp)):
186 raise IOError, "The file %s has not a valid header" %(filename)
185 raise IOError, "The file %s has not a valid header" %(filename)
187
186
188 fp.close()
187 fp.close()
189
188
190 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
189 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
191 return 0
190 return 0
192
191
193 return 1
192 return 1
194
193
195
194 class VoltageReader(JRODataReader):
196 class VoltageReader(DataReader):
197 """
195 """
198 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
196 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
199 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
197 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
200 perfiles*alturas*canales) son almacenados en la variable "buffer".
198 perfiles*alturas*canales) son almacenados en la variable "buffer".
201
199
202 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
200 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
203 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
201 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
204 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
202 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
205 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
203 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
206
204
207 Example:
205 Example:
208
206
209 dpath = "/home/myuser/data"
207 dpath = "/home/myuser/data"
210
208
211 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
209 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
212
210
213 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
211 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
214
212
215 readerObj = VoltageReader()
213 readerObj = VoltageReader()
216
214
217 readerObj.setup(dpath, startTime, endTime)
215 readerObj.setup(dpath, startTime, endTime)
218
216
219 while(True):
217 while(True):
220
218
221 #to get one profile
219 #to get one profile
222 profile = readerObj.getData()
220 profile = readerObj.getData()
223
221
224 #print the profile
222 #print the profile
225 print profile
223 print profile
226
224
227 #If you want to see all datablock
225 #If you want to see all datablock
228 print readerObj.datablock
226 print readerObj.datablock
229
227
230 if readerObj.noMoreFiles:
228 if readerObj.noMoreFiles:
231 break
229 break
232
230
233 """
231 """
234
232
235 #speed of light
233 #speed of light
236 __c = 3E8
234 __c = 3E8
237
235
238
236
239 def __init__(self,m_Voltage=None):
237 def __init__(self,m_Voltage=None):
240 """
238 """
241 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
239 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
242
240
243 Input:
241 Input:
244 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
242 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
245 almacenar un perfil de datos cada vez que se haga un requerimiento
243 almacenar un perfil de datos cada vez que se haga un requerimiento
246 (getData). El perfil sera obtenido a partir del buffer de datos,
244 (getData). El perfil sera obtenido a partir del buffer de datos,
247 si el buffer esta vacio se hara un nuevo proceso de lectura de un
245 si el buffer esta vacio se hara un nuevo proceso de lectura de un
248 bloque de datos.
246 bloque de datos.
249 Si este parametro no es pasado se creara uno internamente.
247 Si este parametro no es pasado se creara uno internamente.
250
248
251 Variables afectadas:
249 Variables afectadas:
252 self.m_Voltage
250 self.m_Voltage
253 self.m_BasicHeader
251 self.m_BasicHeader
254 self.m_SystemHeader
252 self.m_SystemHeader
255 self.m_RadarControllerHeader
253 self.m_RadarControllerHeader
256 self.m_ProcessingHeader
254 self.m_ProcessingHeader
257
255
258
256
259 Return:
257 Return:
260 Void
258 Void
261
259
262 """
260 """
263 if m_Voltage == None:
261 if m_Voltage == None:
264 m_Voltage = Voltage()
262 m_Voltage = Voltage()
265
263
266 if not(isinstance(m_Voltage, Voltage)):
264 if not(isinstance(m_Voltage, Voltage)):
267 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
265 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
268
266
269 self.m_Voltage = m_Voltage
267 self.m_Voltage = m_Voltage
270
268
271 self.m_BasicHeader = BasicHeader()
269 self.m_BasicHeader = BasicHeader()
272
270
273 self.m_SystemHeader = SystemHeader()
271 self.m_SystemHeader = SystemHeader()
274
272
275 self.m_RadarControllerHeader = RadarControllerHeader()
273 self.m_RadarControllerHeader = RadarControllerHeader()
276
274
277 self.m_ProcessingHeader = ProcessingHeader()
275 self.m_ProcessingHeader = ProcessingHeader()
278
276
279 self.__fp = None
277 self.__fp = None
280
278
281 self.__idFile = None
279 self.__idFile = None
282
280
283 self.__startDateTime = None
281 self.__startDateTime = None
284
282
285 self.__endDateTime = None
283 self.__endDateTime = None
286
284
287 self.__dataType = None
285 self.__dataType = None
288
286
289 self.__fileSizeByHeader = 0
287 self.__fileSizeByHeader = 0
290
288
291 self.__pathList = []
289 self.__pathList = []
292
290
293 self.filenameList = []
291 self.filenameList = []
294
292
295 self.__lastUTTime = 0
293 self.__lastUTTime = 0
296
294
297 self.__maxTimeStep = 30
295 self.__maxTimeStep = 30
298
296
299 self.__flagIsNewFile = 0
297 self.__flagIsNewFile = 0
300
298
301 self.__ippSeconds = 0
299 self.__ippSeconds = 0
302
300
303 self.flagResetProcessing = 0
301 self.flagResetProcessing = 0
304
302
305 self.flagIsNewBlock = 0
303 self.flagIsNewBlock = 0
306
304
307 self.noMoreFiles = 0
305 self.noMoreFiles = 0
308
306
309 self.nReadBlocks = 0
307 self.nReadBlocks = 0
310
308
311 self.online = 0
309 self.online = 0
312
310
313 self.filename = None
311 self.filename = None
314
312
315 self.fileSize = None
313 self.fileSize = None
316
314
317 self.firstHeaderSize = 0
315 self.firstHeaderSize = 0
318
316
319 self.basicHeaderSize = 24
317 self.basicHeaderSize = 24
320
318
321 self.idProfile = 0
319 self.idProfile = 0
322
320
323 self.datablock = None
321 self.datablock = None
324
322
325 self.__datablockIndex = 9999
323 self.__datablockIndex = 9999
326
324
327 self.__delay = 7 #seconds
325 self.__delay = 7 #seconds
328 self.__nTries = 3 #quantity tries
326 self.__nTries = 3 #quantity tries
329 self.__nFiles = 3 #number of files for searching
327 self.__nFiles = 3 #number of files for searching
330 self.__year = 0
328 self.__year = 0
331 self.__doy = 0
329 self.__doy = 0
332 self.__set = 0
330 self.__set = 0
333 self.__ext = None
331 self.__ext = None
334 self.__path = None
332 self.__path = None
335 self.__pts2read = 0
333 self.__pts2read = 0
336 self.__blocksize = 0
334 self.__blocksize = 0
337 self.__utc = 0
335 self.__utc = 0
338 self.nBlocks = 0
336 self.nBlocks = 0
339
337
340
338
341 def __rdSystemHeader(self,fp=None):
339 def __rdSystemHeader(self,fp=None):
342 if fp == None:
340 if fp == None:
343 fp = self.__fp
341 fp = self.__fp
344
342
345 self.m_SystemHeader.read(fp)
343 self.m_SystemHeader.read(fp)
346
344
347
345
348 def __rdRadarControllerHeader(self,fp=None):
346 def __rdRadarControllerHeader(self,fp=None):
349 if fp == None:
347 if fp == None:
350 fp = self.__fp
348 fp = self.__fp
351
349
352 self.m_RadarControllerHeader.read(fp)
350 self.m_RadarControllerHeader.read(fp)
353
351
354
352
355 def __rdProcessingHeader(self,fp=None):
353 def __rdProcessingHeader(self,fp=None):
356 if fp == None:
354 if fp == None:
357 fp = self.__fp
355 fp = self.__fp
358
356
359 self.m_ProcessingHeader.read(fp)
357 self.m_ProcessingHeader.read(fp)
360
358
361
359
362 def __rdBasicHeader(self,fp=None):
360 def __rdBasicHeader(self,fp=None):
363
361
364 if fp == None:
362 if fp == None:
365 fp = self.__fp
363 fp = self.__fp
366
364
367 self.m_BasicHeader.read(fp)
365 self.m_BasicHeader.read(fp)
368
366
369
367
370 def __readFirstHeader(self):
368 def __readFirstHeader(self):
371 """
369 """
372 Lectura del First Header, es decir el Basic Header y el Long Header
370 Lectura del First Header, es decir el Basic Header y el Long Header
373
371
374 Affected:
372 Affected:
375 self.m_BasicHeader
373 self.m_BasicHeader
376 self.m_SystemHeader
374 self.m_SystemHeader
377 self.m_RadarControllerHeader
375 self.m_RadarControllerHeader
378 self.m_ProcessingHeader
376 self.m_ProcessingHeader
379 self.firstHeaderSize
377 self.firstHeaderSize
380 self.__heights
378 self.__heights
381 self.__dataType
379 self.__dataType
382 self.__fileSizeByHeader
380 self.__fileSizeByHeader
383 self.__ippSeconds
381 self.__ippSeconds
384 self.__blocksize
382 self.__blocksize
385 self.__pts2read
383 self.__pts2read
386
384
387 Return: None
385 Return: None
388 """
386 """
389 self.__rdBasicHeader()
387 self.__rdBasicHeader()
390 self.__rdSystemHeader()
388 self.__rdSystemHeader()
391 self.__rdRadarControllerHeader()
389 self.__rdRadarControllerHeader()
392 self.__rdProcessingHeader()
390 self.__rdProcessingHeader()
393 self.firstHeaderSize = self.m_BasicHeader.size
391 self.firstHeaderSize = self.m_BasicHeader.size
394
392
395 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
393 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
396 if data_type == 0:
394 if data_type == 0:
397 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
395 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
398
396
399 elif data_type == 1:
397 elif data_type == 1:
400 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
398 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
401
399
402 elif data_type == 2:
400 elif data_type == 2:
403 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
401 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
404
402
405 elif data_type == 3:
403 elif data_type == 3:
406 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
404 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
407
405
408 elif data_type == 4:
406 elif data_type == 4:
409 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
407 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
410
408
411 elif data_type == 5:
409 elif data_type == 5:
412 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
410 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
413
411
414 else:
412 else:
415 raise ValueError, 'Data type was not defined'
413 raise ValueError, 'Data type was not defined'
416
414
417 xi = self.m_ProcessingHeader.firstHeight
415 xi = self.m_ProcessingHeader.firstHeight
418 step = self.m_ProcessingHeader.deltaHeight
416 step = self.m_ProcessingHeader.deltaHeight
419 xf = xi + self.m_ProcessingHeader.numHeights*step
417 xf = xi + self.m_ProcessingHeader.numHeights*step
420
418
421 self.__heights = numpy.arange(xi, xf, step)
419 self.__heights = numpy.arange(xi, xf, step)
422 self.__dataType = tmp
420 self.__dataType = tmp
423 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
421 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
424 self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/self.__c
422 self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/self.__c
425
423
426 self.__pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
424 self.__pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
427 self.__blocksize = self.__pts2read
425 self.__blocksize = self.__pts2read
428
426
429
427
430 def __setNextFileOnline(self):
428 def __setNextFileOnline(self):
431 """
429 """
432 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
430 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
433 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
431 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
434 siguientes.
432 siguientes.
435
433
436 Affected:
434 Affected:
437 self.__flagIsNewFile
435 self.__flagIsNewFile
438 self.filename
436 self.filename
439 self.fileSize
437 self.fileSize
440 self.__fp
438 self.__fp
441 self.__set
439 self.__set
442 self.noMoreFiles
440 self.noMoreFiles
443
441
444 Return:
442 Return:
445 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
443 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
446 1 : si el file fue abierto con exito y esta listo a ser leido
444 1 : si el file fue abierto con exito y esta listo a ser leido
447
445
448 Excepciones:
446 Excepciones:
449 Si un determinado file no puede ser abierto
447 Si un determinado file no puede ser abierto
450 """
448 """
451 countFiles = 0
449 countFiles = 0
452 countTries = 0
450 countTries = 0
453
451
454 notFirstTime_flag = False
452 notFirstTime_flag = False
455 fileOk_flag = False
453 fileOk_flag = False
456 changeDir_flag = False
454 changeDir_flag = False
457
455
458 self.__flagIsNewFile = 0
456 self.__flagIsNewFile = 0
459
457
460 while( True ): #este loop permite llevar la cuenta de intentos, de files y carpetas,
458 while( True ): #este loop permite llevar la cuenta de intentos, de files y carpetas,
461 #si no encuentra alguno sale del bucle
459 #si no encuentra alguno sale del bucle
462 countFiles += 1
460 countFiles += 1
463
461
464 if countFiles > (self.__nFiles + 1):
462 if countFiles > (self.__nFiles + 1):
465 break
463 break
466
464
467 self.__set += 1
465 self.__set += 1
468
466
469 if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
467 if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
470 self.__set = 0
468 self.__set = 0
471 self.__doy += 1
469 self.__doy += 1
472 changeDir_flag = True
470 changeDir_flag = True
473
471
474 file = None
472 file = None
475 filename = None
473 filename = None
476 fileOk_flag = False
474 fileOk_flag = False
477
475
478 #busca el 1er file disponible
476 #busca el 1er file disponible
479 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
477 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
480
478
481 if file == None:
479 if file == None:
482 if notFirstTime_flag: #si no es la primera vez que busca el file entonces no espera y busca for el siguiente file
480 if notFirstTime_flag: #si no es la primera vez que busca el file entonces no espera y busca for el siguiente file
483 print "\tsearching next \"%s\" file ..." % ( filename )
481 print "\tsearching next \"%s\" file ..." % ( filename )
484 continue
482 continue
485 else: #si es la primera vez que busca el file entonces espera self.__nTries veces hasta encontrarlo o no
483 else: #si es la primera vez que busca el file entonces espera self.__nTries veces hasta encontrarlo o no
486 for nTries in range( self.__nTries ):
484 for nTries in range( self.__nTries ):
487 print "\twaiting new \"%s\" file, try %03d ..." % ( filename, nTries+1 )
485 print "\twaiting new \"%s\" file, try %03d ..." % ( filename, nTries+1 )
488 time.sleep( self.__delay )
486 time.sleep( self.__delay )
489
487
490 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
488 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
491 if file != None:
489 if file != None:
492 fileOk_flag = True
490 fileOk_flag = True
493 break
491 break
494
492
495 if not( fileOk_flag ): #no encontro ningun file valido a leer despues de haber esperado alguno
493 if not( fileOk_flag ): #no encontro ningun file valido a leer despues de haber esperado alguno
496 notFirstTime_flag = True
494 notFirstTime_flag = True
497 continue
495 continue
498
496
499 #una vez que se obtuvo el 1er file valido se procede a checkear si si tamanho es suficiente para empezar a leerlo
497 #una vez que se obtuvo el 1er file valido se procede a checkear si si tamanho es suficiente para empezar a leerlo
500 currentSize = os.path.getsize( file )
498 currentSize = os.path.getsize( file )
501 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
499 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
502
500
503 #si el tamanho es suficiente entonces deja de buscar
501 #si el tamanho es suficiente entonces deja de buscar
504 if currentSize > neededSize:# and (neededSize != 0):
502 if currentSize > neededSize:# and (neededSize != 0):
505 fileOk_flag = True
503 fileOk_flag = True
506 break
504 break
507
505
508 fileOk_flag = False
506 fileOk_flag = False
509 #si el file no tiene el tamanho necesario se espera una cierta cantidad de tiempo
507 #si el file no tiene el tamanho necesario se espera una cierta cantidad de tiempo
510 #por una cierta cantidad de veces hasta que el contenido del file sea valido
508 #por una cierta cantidad de veces hasta que el contenido del file sea valido
511 if changeDir_flag: #si al buscar un file cambie de directorio ya no espero y sigo con el siguiente file
509 if changeDir_flag: #si al buscar un file cambie de directorio ya no espero y sigo con el siguiente file
512 print "\tsearching next \"%s\" file ..." % filename
510 print "\tsearching next \"%s\" file ..." % filename
513 changeDir_flag = False
511 changeDir_flag = False
514 continue
512 continue
515
513
516 for nTries in range( self.__nTries ):
514 for nTries in range( self.__nTries ):
517 print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 )
515 print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 )
518 time.sleep( self.__delay )
516 time.sleep( self.__delay )
519
517
520 currentSize = os.path.getsize( file )
518 currentSize = os.path.getsize( file )
521 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
519 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
522
520
523 if currentSize > neededSize:
521 if currentSize > neededSize:
524 fileOk_flag = True
522 fileOk_flag = True
525 break
523 break
526
524
527 if fileOk_flag: #si encontro un file valido sale del bucle y deja de buscar
525 if fileOk_flag: #si encontro un file valido sale del bucle y deja de buscar
528 break
526 break
529
527
530 print "Skipping the file \"%s\" due to this files is empty" % filename
528 print "Skipping the file \"%s\" due to this files is empty" % filename
531 countFiles = 0
529 countFiles = 0
532
530
533 if fileOk_flag:
531 if fileOk_flag:
534 self.fileSize = os.path.getsize( file ) #fileSize
532 self.fileSize = os.path.getsize( file ) #fileSize
535 self.filename = file
533 self.filename = file
536 self.__flagIsNewFile = 1
534 self.__flagIsNewFile = 1
537 if self.__fp != None: self.__fp.close()
535 if self.__fp != None: self.__fp.close()
538 self.__fp = open(file)
536 self.__fp = open(file)
539 self.noMoreFiles = 0
537 self.noMoreFiles = 0
540 print 'Setting the file: %s' % file
538 print 'Setting the file: %s' % file
541 else:
539 else:
542 self.fileSize = 0
540 self.fileSize = 0
543 self.filename = None
541 self.filename = None
544 self.__fp = None
542 self.__fp = None
545 self.noMoreFiles = 1
543 self.noMoreFiles = 1
546 print 'No more Files'
544 print 'No more Files'
547
545
548 return fileOk_flag
546 return fileOk_flag
549
547
550
548
551 def __setNextFileOffline(self):
549 def __setNextFileOffline(self):
552
550
553 idFile = self.__idFile
551 idFile = self.__idFile
554 while(True):
552 while(True):
555
553
556 idFile += 1
554 idFile += 1
557
555
558 if not(idFile < len(self.filenameList)):
556 if not(idFile < len(self.filenameList)):
559 self.noMoreFiles = 1
557 self.noMoreFiles = 1
560 print 'No more Files'
558 print 'No more Files'
561 return 0
559 return 0
562
560
563 filename = self.filenameList[idFile]
561 filename = self.filenameList[idFile]
564 fileSize = os.path.getsize(filename)
562 fileSize = os.path.getsize(filename)
565
563
566 try:
564 try:
567 fp = open(filename,'rb')
565 fp = open(filename,'rb')
568 except:
566 except:
569 raise IOError, "The file %s can't be opened" %filename
567 raise IOError, "The file %s can't be opened" %filename
570
568
571 currentSize = fileSize - fp.tell()
569 currentSize = fileSize - fp.tell()
572 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
570 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
573
571
574 if (currentSize < neededSize):
572 if (currentSize < neededSize):
575 print "Skipping the file %s due to it hasn't enough data" %filename
573 print "Skipping the file %s due to it hasn't enough data" %filename
576 continue
574 continue
577
575
578 break
576 break
579
577
580 self.__flagIsNewFile = 1
578 self.__flagIsNewFile = 1
581 self.__idFile = idFile
579 self.__idFile = idFile
582 self.filename = filename
580 self.filename = filename
583 self.fileSize = fileSize
581 self.fileSize = fileSize
584 self.__fp = fp
582 self.__fp = fp
585
583
586 print 'Setting the file: %s'%self.filename
584 print 'Setting the file: %s'%self.filename
587
585
588 return 1
586 return 1
589
587
590
588
591 def __setNextFile(self):
589 def __setNextFile(self):
592 """
590 """
593 Determina el siguiente file a leer y si hay uno disponible lee el First Header
591 Determina el siguiente file a leer y si hay uno disponible lee el First Header
594
592
595 Affected:
593 Affected:
596 self.m_BasicHeader
594 self.m_BasicHeader
597 self.m_SystemHeader
595 self.m_SystemHeader
598 self.m_RadarControllerHeader
596 self.m_RadarControllerHeader
599 self.m_ProcessingHeader
597 self.m_ProcessingHeader
600 self.firstHeaderSize
598 self.firstHeaderSize
601
599
602 Return:
600 Return:
603 0 : Si no hay files disponibles
601 0 : Si no hay files disponibles
604 1 : Si hay mas files disponibles
602 1 : Si hay mas files disponibles
605 """
603 """
606 if self.__fp != None:
604 if self.__fp != None:
607 self.__fp.close()
605 self.__fp.close()
608
606
609 if self.online:
607 if self.online:
610 newFile = self.__setNextFileOnline()
608 newFile = self.__setNextFileOnline()
611 else:
609 else:
612 newFile = self.__setNextFileOffline()
610 newFile = self.__setNextFileOffline()
613
611
614 if self.noMoreFiles:
612 if self.noMoreFiles:
615 sys.exit(0)
613 sys.exit(0)
616
614
617 if not(newFile):
615 if not(newFile):
618 return 0
616 return 0
619
617
620 self.__readFirstHeader()
618 self.__readFirstHeader()
621 self.nBlocks = 0
619 self.nBlocks = 0
622 return 1
620 return 1
623
621
624
622
625 def __setNewBlock(self):
623 def __setNewBlock(self):
626 """
624 """
627 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
625 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
628
626
629 Affected:
627 Affected:
630 self.m_BasicHeader
628 self.m_BasicHeader
631 self.flagResetProcessing
629 self.flagResetProcessing
632 self.ns
630 self.ns
633
631
634 Return:
632 Return:
635 0 : Si el file no tiene un Basic Header que pueda ser leido
633 0 : Si el file no tiene un Basic Header que pueda ser leido
636 1 : Si se pudo leer el Basic Header
634 1 : Si se pudo leer el Basic Header
637 """
635 """
638 if self.__fp == None:
636 if self.__fp == None:
639 return 0
637 return 0
640
638
641 if self.__flagIsNewFile:
639 if self.__flagIsNewFile:
642 return 1
640 return 1
643
641
644 currentSize = self.fileSize - self.__fp.tell()
642 currentSize = self.fileSize - self.__fp.tell()
645 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
643 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
646
644
647 #If there is enough data setting new data block
645 #If there is enough data setting new data block
648 if ( currentSize >= neededSize ):
646 if ( currentSize >= neededSize ):
649 self.__rdBasicHeader()
647 self.__rdBasicHeader()
650 return 1
648 return 1
651
649
652 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
650 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
653 elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
651 elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
654 for nTries in range( self.__nTries ):
652 for nTries in range( self.__nTries ):
655
653
656 fpointer = self.__fp.tell()
654 fpointer = self.__fp.tell()
657 self.__fp.close()
655 self.__fp.close()
658
656
659 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
657 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
660 time.sleep( self.__delay )
658 time.sleep( self.__delay )
661
659
662 self.__fp = open( self.filename, 'rb' )
660 self.__fp = open( self.filename, 'rb' )
663 self.__fp.seek( fpointer )
661 self.__fp.seek( fpointer )
664
662
665 self.fileSize = os.path.getsize( self.filename )
663 self.fileSize = os.path.getsize( self.filename )
666 currentSize = self.fileSize - self.__fp.tell()
664 currentSize = self.fileSize - self.__fp.tell()
667 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
665 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
668
666
669 if ( currentSize >= neededSize ):
667 if ( currentSize >= neededSize ):
670 self.__rdBasicHeader()
668 self.__rdBasicHeader()
671 return 1
669 return 1
672
670
673 #Setting new file
671 #Setting new file
674 if not( self.__setNextFile() ):
672 if not( self.__setNextFile() ):
675 return 0
673 return 0
676
674
677 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
675 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
678
676
679 self.flagResetProcessing = 0
677 self.flagResetProcessing = 0
680
678
681 if deltaTime > self.__maxTimeStep:
679 if deltaTime > self.__maxTimeStep:
682 self.flagResetProcessing = 1
680 self.flagResetProcessing = 1
683 #self.nReadBlocks = 0
681 #self.nReadBlocks = 0
684
682
685 return 1
683 return 1
686
684
687
685
688 def __readBlock(self):
686 def __readBlock(self):
689 """
687 """
690 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
688 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
691 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
689 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
692 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
690 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
693 es seteado a 0
691 es seteado a 0
694
692
695 Inputs:
693 Inputs:
696 None
694 None
697
695
698 Return:
696 Return:
699 None
697 None
700
698
701 Affected:
699 Affected:
702 self.__datablockIndex
700 self.__datablockIndex
703 self.datablock
701 self.datablock
704 self.__flagIsNewFile
702 self.__flagIsNewFile
705 self.idProfile
703 self.idProfile
706 self.flagIsNewBlock
704 self.flagIsNewBlock
707 self.nReadBlocks
705 self.nReadBlocks
708
706
709 Exceptions:
707 Exceptions:
710 Si un bloque leido no es un bloque valido
708 Si un bloque leido no es un bloque valido
711 """
709 """
712 blockOk_flag = False
710 blockOk_flag = False
713 fpointer = self.__fp.tell()
711 fpointer = self.__fp.tell()
714
712
715 junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
713 junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
716
714
717 if self.online:
715 if self.online:
718 if junk.size != self.__blocksize:
716 if junk.size != self.__blocksize:
719 for nTries in range( self.__nTries ):
717 for nTries in range( self.__nTries ):
720 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
718 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
721 time.sleep( self.__delay )
719 time.sleep( self.__delay )
722 self.__fp.seek( fpointer )
720 self.__fp.seek( fpointer )
723 fpointer = self.__fp.tell()
721 fpointer = self.__fp.tell()
724 junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
722 junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
725 if junk.size == self.__blocksize:
723 if junk.size == self.__blocksize:
726 blockOk_flag = True
724 blockOk_flag = True
727 break
725 break
728
726
729 if not( blockOk_flag ):
727 if not( blockOk_flag ):
730 return 0
728 return 0
731
729
732 try:
730 try:
733 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
731 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
734 except:
732 except:
735 print "Data file %s is invalid" % self.filename
733 print "Data file %s is invalid" % self.filename
736 return 0
734 return 0
737
735
738 #data = junk['real'] + junk['imag']*1j
736 #data = junk['real'] + junk['imag']*1j
739 self.datablock = junk['real'] + junk['imag']*1j
737 self.datablock = junk['real'] + junk['imag']*1j
740
738
741 self.__datablockIndex = 0
739 self.__datablockIndex = 0
742 self.__flagIsNewFile = 0
740 self.__flagIsNewFile = 0
743 self.idProfile = 0
741 self.idProfile = 0
744 self.flagIsNewBlock = 1
742 self.flagIsNewBlock = 1
745
743
746 self.nReadBlocks += 1
744 self.nReadBlocks += 1
747 self.nBlocks += 1
745 self.nBlocks += 1
748
746
749 return 1
747 return 1
750
748
751
749
752 def __hasNotDataInBuffer(self):
750 def __hasNotDataInBuffer(self):
753 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
751 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
754 return 1
752 return 1
755 return 0
753 return 0
756
754
757
755
758 def __searchFilesOnLine(self, path, startDateTime=None, ext = ".r"):
756 def __searchFilesOnLine(self, path, startDateTime=None, ext = ".r"):
759 """
757 """
760 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
758 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
761 devuelve el archivo encontrado ademas de otros datos.
759 devuelve el archivo encontrado ademas de otros datos.
762
760
763 Input:
761 Input:
764 path : carpeta donde estan contenidos los files que contiene data
762 path : carpeta donde estan contenidos los files que contiene data
765 startDateTime : punto especifico en el tiempo del cual se requiere la data
763 startDateTime : punto especifico en el tiempo del cual se requiere la data
766 ext : extension de los files
764 ext : extension de los files
767
765
768 Return:
766 Return:
769 year : el anho
767 year : el anho
770 doy : el numero de dia del anho
768 doy : el numero de dia del anho
771 set : el set del archivo
769 set : el set del archivo
772 filename : el ultimo file de una determinada carpeta
770 filename : el ultimo file de una determinada carpeta
773 directory : eL directorio donde esta el file encontrado
771 directory : eL directorio donde esta el file encontrado
774 """
772 """
775 print "Searching files ..."
773 print "Searching files ..."
776
774
777 dirList = []
775 dirList = []
778 directory = None
776 directory = None
779
777
780 if startDateTime == None:
778 if startDateTime == None:
781 for thisPath in os.listdir(path):
779 for thisPath in os.listdir(path):
782 if os.path.isdir( os.path.join(path,thisPath) ):
780 if os.path.isdir( os.path.join(path,thisPath) ):
783 dirList.append( thisPath )
781 dirList.append( thisPath )
784
782
785 dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted
783 dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted
786 if len(dirList) > 0 :
784 if len(dirList) > 0 :
787 directory = dirList[-1] #me quedo con el ultimo directorio de una carpeta
785 directory = dirList[-1] #me quedo con el ultimo directorio de una carpeta
788 else:
786 else:
789 year = startDateTime.timetuple().tm_year
787 year = startDateTime.timetuple().tm_year
790 doy = startDateTime.timetuple().tm_yday
788 doy = startDateTime.timetuple().tm_yday
791
789
792 doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas
790 doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas
793 if os.path.isdir( os.path.join(path,doyPath) ):
791 if os.path.isdir( os.path.join(path,doyPath) ):
794 directory = doyPath
792 directory = doyPath
795
793
796 doyPath = doyPath.lower() #caso del nombre en minusculas
794 doyPath = doyPath.lower() #caso del nombre en minusculas
797 if os.path.isdir( os.path.join(path,doyPath) ):
795 if os.path.isdir( os.path.join(path,doyPath) ):
798 directory = doyPath
796 directory = doyPath
799
797
800 if directory == None:
798 if directory == None:
801 return 0, 0, 0, None, None
799 return 0, 0, 0, None, None
802
800
803 filename = getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext )
801 filename = getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext )
804
802
805 if filename == None:
803 if filename == None:
806 return 0, 0, 0, None, None
804 return 0, 0, 0, None, None
807
805
808 year = int( directory[-7:-3] )
806 year = int( directory[-7:-3] )
809 doy = int( directory[-3:] )
807 doy = int( directory[-3:] )
810 ln = len( ext )
808 ln = len( ext )
811 set = int( filename[-ln-3:-ln] )
809 set = int( filename[-ln-3:-ln] )
812
810
813 return year, doy, set, filename, directory
811 return year, doy, set, filename, directory
814
812
815
813
816 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
814 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
817 """
815 """
818 Realiza una busqueda de los archivos que coincidan con los parametros
816 Realiza una busqueda de los archivos que coincidan con los parametros
819 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
817 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
820 correcta la estructura de directorios debe ser la siguiente:
818 correcta la estructura de directorios debe ser la siguiente:
821
819
822 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
820 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
823
821
824 [yyyy]: anio
822 [yyyy]: anio
825 [ddd] : dia del anio
823 [ddd] : dia del anio
826 [sss] : set del archivo
824 [sss] : set del archivo
827
825
828 Inputs:
826 Inputs:
829 path : Directorio de datos donde se realizara la busqueda. Todos los
827 path : Directorio de datos donde se realizara la busqueda. Todos los
830 ficheros que concidan con el criterio de busqueda seran
828 ficheros que concidan con el criterio de busqueda seran
831 almacenados en una lista y luego retornados.
829 almacenados en una lista y luego retornados.
832 startDateTime : Fecha inicial. Rechaza todos los archivos donde
830 startDateTime : Fecha inicial. Rechaza todos los archivos donde
833 file end time < startDateTime (obejto datetime.datetime)
831 file end time < startDateTime (obejto datetime.datetime)
834
832
835 endDateTime : Fecha final. Rechaza todos los archivos donde
833 endDateTime : Fecha final. Rechaza todos los archivos donde
836 file start time > endDateTime (obejto datetime.datetime)
834 file start time > endDateTime (obejto datetime.datetime)
837
835
838 set : Set del primer archivo a leer. Por defecto None
836 set : Set del primer archivo a leer. Por defecto None
839
837
840 expLabel : Nombre del subdirectorio de datos. Por defecto ""
838 expLabel : Nombre del subdirectorio de datos. Por defecto ""
841
839
842 ext : Extension de los archivos a leer. Por defecto .r
840 ext : Extension de los archivos a leer. Por defecto .r
843
841
844 Return:
842 Return:
845
843
846 (pathList, filenameList)
844 (pathList, filenameList)
847
845
848 pathList : Lista de directorios donde se encontraron archivos dentro
846 pathList : Lista de directorios donde se encontraron archivos dentro
849 de los parametros especificados
847 de los parametros especificados
850 filenameList : Lista de archivos (ruta completa) que coincidieron con los
848 filenameList : Lista de archivos (ruta completa) que coincidieron con los
851 parametros especificados.
849 parametros especificados.
852
850
853 Variables afectadas:
851 Variables afectadas:
854
852
855 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
853 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
856 como fuente para leer los bloque de datos, si se termina
854 como fuente para leer los bloque de datos, si se termina
857 de leer todos los bloques de datos de un determinado
855 de leer todos los bloques de datos de un determinado
858 archivo se pasa al siguiente archivo de la lista.
856 archivo se pasa al siguiente archivo de la lista.
859
857
860 Excepciones:
858 Excepciones:
861
859
862 """
860 """
863 print "Searching files ..."
861 print "Searching files ..."
864
862
865 dirList = []
863 dirList = []
866 for thisPath in os.listdir(path):
864 for thisPath in os.listdir(path):
867 if os.path.isdir(os.path.join(path,thisPath)):
865 if os.path.isdir(os.path.join(path,thisPath)):
868 dirList.append(thisPath)
866 dirList.append(thisPath)
869
867
870 pathList = []
868 pathList = []
871
869
872 thisDateTime = startDateTime
870 thisDateTime = startDateTime
873
871
874 while(thisDateTime <= endDateTime):
872 while(thisDateTime <= endDateTime):
875 year = thisDateTime.timetuple().tm_year
873 year = thisDateTime.timetuple().tm_year
876 doy = thisDateTime.timetuple().tm_yday
874 doy = thisDateTime.timetuple().tm_yday
877
875
878 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
876 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
879 if len(match) == 0:
877 if len(match) == 0:
880 thisDateTime += datetime.timedelta(1)
878 thisDateTime += datetime.timedelta(1)
881 continue
879 continue
882
880
883 pathList.append(os.path.join(path,match[0],expLabel))
881 pathList.append(os.path.join(path,match[0],expLabel))
884 thisDateTime += datetime.timedelta(1)
882 thisDateTime += datetime.timedelta(1)
885
883
886 startUtSeconds = time.mktime(startDateTime.timetuple())
884 startUtSeconds = time.mktime(startDateTime.timetuple())
887 endUtSeconds = time.mktime(endDateTime.timetuple())
885 endUtSeconds = time.mktime(endDateTime.timetuple())
888
886
889 filenameList = []
887 filenameList = []
890 for thisPath in pathList:
888 for thisPath in pathList:
891 fileList = glob.glob1(thisPath, "*%s" %ext)
889 fileList = glob.glob1(thisPath, "*%s" %ext)
892 fileList.sort()
890 fileList.sort()
893 for file in fileList:
891 for file in fileList:
894 filename = os.path.join(thisPath,file)
892 filename = os.path.join(thisPath,file)
895 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
893 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
896 filenameList.append(filename)
894 filenameList.append(filename)
897
895
898 self.filenameList = filenameList
896 self.filenameList = filenameList
899
897
900 return pathList, filenameList
898 return pathList, filenameList
901
899
902
900
903 def __initFilesOnline( self, path, dirfilename, filename ):
901 def __initFilesOnline( self, path, dirfilename, filename ):
904 """
902 """
905 Verifica que el primer file tenga una data valida, para ello leo el 1er bloque
903 Verifica que el primer file tenga una data valida, para ello leo el 1er bloque
906 del file, si no es un file valido espera una cierta cantidad de tiempo a que
904 del file, si no es un file valido espera una cierta cantidad de tiempo a que
907 lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo
905 lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo
908 devuelve 0 caso contrario devuelve 1
906 devuelve 0 caso contrario devuelve 1
909
907
910 Affected:
908 Affected:
911 m_BasicHeader
909 m_BasicHeader
912
910
913 Return:
911 Return:
914 0 : file no valido para ser leido
912 0 : file no valido para ser leido
915 1 : file valido para ser leido
913 1 : file valido para ser leido
916 """
914 """
917 m_BasicHeader = BasicHeader()
915 m_BasicHeader = BasicHeader()
918
916
919 file = os.path.join( path, dirfilename, filename )
917 file = os.path.join( path, dirfilename, filename )
920
918
921 for nTries in range( self.__nTries+1 ):
919 for nTries in range( self.__nTries+1 ):
922 try:
920 try:
923 fp = open( file,'rb' ) #lectura binaria
921 fp = open( file,'rb' ) #lectura binaria
924 except:
922 except:
925 raise IOError, "The file %s can't be opened" % (file)
923 raise IOError, "The file %s can't be opened" % (file)
926
924
927 try:
925 try:
928 m_BasicHeader.read(fp)
926 m_BasicHeader.read(fp)
929 except:
927 except:
930 print "The file %s is empty" % filename
928 print "The file %s is empty" % filename
931
929
932 fp.close()
930 fp.close()
933 fp = None
931 fp = None
934
932
935 if m_BasicHeader.size > 24:
933 if m_BasicHeader.size > 24:
936 break
934 break
937
935
938 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
936 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
939 break
937 break
940
938
941 print '\twaiting for new block: try %02d' % ( nTries )
939 print '\twaiting for new block: try %02d' % ( nTries )
942 time.sleep( self.__delay )
940 time.sleep( self.__delay )
943
941
944 if m_BasicHeader.size <= 24:
942 if m_BasicHeader.size <= 24:
945 return 0
943 return 0
946
944
947 return 1
945 return 1
948
946
949
947
950 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0):
948 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0):
951 """
949 """
952 setup configura los parametros de lectura de la clase VoltageReader.
950 setup configura los parametros de lectura de la clase VoltageReader.
953
951
954 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
952 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
955 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
953 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
956 self.filenameList.
954 self.filenameList.
957
955
958 Input:
956 Input:
959 path : Directorios donde se ubican los datos a leer. Dentro de este
957 path : Directorios donde se ubican los datos a leer. Dentro de este
960 directorio deberia de estar subdirectorios de la forma:
958 directorio deberia de estar subdirectorios de la forma:
961
959
962 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
960 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
963
961
964 startDateTime : Fecha inicial. Rechaza todos los archivos donde
962 startDateTime : Fecha inicial. Rechaza todos los archivos donde
965 file end time < startDatetime (obejto datetime.datetime)
963 file end time < startDatetime (obejto datetime.datetime)
966
964
967 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
965 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
968 file end time < startDatetime (obejto datetime.datetime)
966 file end time < startDatetime (obejto datetime.datetime)
969
967
970 set : Set del primer archivo a leer. Por defecto None
968 set : Set del primer archivo a leer. Por defecto None
971
969
972 expLabel : Nombre del subdirectorio de datos. Por defecto ""
970 expLabel : Nombre del subdirectorio de datos. Por defecto ""
973
971
974 ext : Extension de los archivos a leer. Por defecto .r
972 ext : Extension de los archivos a leer. Por defecto .r
975
973
976 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
974 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
977
975
978 Return:
976 Return:
979 0 : Si no encuentra files que cumplan con las condiciones dadas
977 0 : Si no encuentra files que cumplan con las condiciones dadas
980 1 : Si encuentra files que cumplan con las condiciones dadas
978 1 : Si encuentra files que cumplan con las condiciones dadas
981
979
982 Affected:
980 Affected:
983 self.startUTCSeconds
981 self.startUTCSeconds
984 self.endUTCSeconds
982 self.endUTCSeconds
985 self.startYear
983 self.startYear
986 self.endYear
984 self.endYear
987 self.startDoy
985 self.startDoy
988 self.endDoy
986 self.endDoy
989 self.__pathList
987 self.__pathList
990 self.filenameList
988 self.filenameList
991 self.online
989 self.online
992 """
990 """
993 if online:
991 if online:
994 fileOK_flag = False
992 fileOK_flag = False
995 subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
993 subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
996 file = os.path.join( path, subfolder )
994 file = os.path.join( path, subfolder )
997
995
998 for nTries in range( self.__nTries+1 ): #espera por el 1er file
996 for nTries in range( self.__nTries+1 ): #espera por el 1er file
999 year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
997 year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
1000
998
1001 if filename != None:
999 if filename != None:
1002 if isFileOK( os.path.join( path,dirfilename,filename ) ):
1000 if isFileOK( os.path.join( path,dirfilename,filename ) ):
1003 fileOK_flag = True
1001 fileOK_flag = True
1004 break
1002 break
1005
1003
1006 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
1004 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
1007 break
1005 break
1008
1006
1009 print "Searching first file in \"%s\", try %03d ..." % ( file, nTries+1 )
1007 print "Searching first file in \"%s\", try %03d ..." % ( file, nTries+1 )
1010 time.sleep( self.__delay )
1008 time.sleep( self.__delay )
1011
1009
1012 if not( fileOK_flag ): #filename == None:
1010 if not( fileOK_flag ): #filename == None:
1013 print "No files on line or invalid first file"
1011 print "No files on line or invalid first file"
1014 return 0
1012 return 0
1015
1013
1016 if self.__initFilesOnline( path, dirfilename, filename ) == 0:
1014 if self.__initFilesOnline( path, dirfilename, filename ) == 0:
1017 print "The file %s hasn't enough data" % filename
1015 print "The file %s hasn't enough data" % filename
1018 return 0
1016 return 0
1019
1017
1020 self.__year = year
1018 self.__year = year
1021 self.__doy = doy
1019 self.__doy = doy
1022 self.__set = set - 1
1020 self.__set = set - 1
1023 self.__path = path
1021 self.__path = path
1024
1022
1025 else:
1023 else:
1026 pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext )
1024 pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext )
1027 self.__idFile = -1
1025 self.__idFile = -1
1028 self.__pathList = pathList
1026 self.__pathList = pathList
1029 self.filenameList = filenameList
1027 self.filenameList = filenameList
1030
1028
1031 self.online = online
1029 self.online = online
1032 self.__ext = ext
1030 self.__ext = ext
1033
1031
1034 if not( self.__setNextFile() ):
1032 if not( self.__setNextFile() ):
1035 if (startDateTime != None) and (endDateTime != None):
1033 if (startDateTime != None) and (endDateTime != None):
1036 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
1034 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
1037 elif startDateTime != None:
1035 elif startDateTime != None:
1038 print "No files in : %s" % startDateTime.ctime()
1036 print "No files in : %s" % startDateTime.ctime()
1039 else:
1037 else:
1040 print "No files"
1038 print "No files"
1041 return 0
1039 return 0
1042
1040
1043 if startDateTime != None:
1041 if startDateTime != None:
1044 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
1042 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
1045 self.startYear = startDateTime.timetuple().tm_year
1043 self.startYear = startDateTime.timetuple().tm_year
1046 self.startDoy = startDateTime.timetuple().tm_yday
1044 self.startDoy = startDateTime.timetuple().tm_yday
1047
1045
1048 if endDateTime != None:
1046 if endDateTime != None:
1049 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
1047 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
1050 self.endYear = endDateTime.timetuple().tm_year
1048 self.endYear = endDateTime.timetuple().tm_year
1051 self.endDoy = endDateTime.timetuple().tm_yday
1049 self.endDoy = endDateTime.timetuple().tm_yday
1052 #call fillHeaderValues() - to Data Object
1050 #call fillHeaderValues() - to Data Object
1053
1051
1054 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
1052 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
1055 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1053 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1056 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1054 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1057 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
1055 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
1058 self.m_Voltage.dataType = self.__dataType
1056 self.m_Voltage.dataType = self.__dataType
1059
1057
1060 return 1
1058 return 1
1061
1059
1062
1060
1063 def readNextBlock(self):
1061 def readNextBlock(self):
1064 """
1062 """
1065 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
1063 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
1066 mas bloques disponibles en el archivo actual salta al siguiente.
1064 mas bloques disponibles en el archivo actual salta al siguiente.
1067
1065
1068 Affected:
1066 Affected:
1069 self.__lastUTTime
1067 self.__lastUTTime
1070
1068
1071 Return: None
1069 Return: None
1072 """
1070 """
1073 if not(self.__setNewBlock()):
1071 if not(self.__setNewBlock()):
1074 return 0
1072 return 0
1075
1073
1076 if not( self.__readBlock() ):
1074 if not( self.__readBlock() ):
1077 return 0
1075 return 0
1078
1076
1079 self.__lastUTTime = self.m_BasicHeader.utc
1077 self.__lastUTTime = self.m_BasicHeader.utc
1080
1078
1081 return 1
1079 return 1
1082
1080
1083
1081
1084 def getData(self):
1082 def getData(self):
1085 """
1083 """
1086 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
1084 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
1087 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1085 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1088 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
1086 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
1089
1087
1090 Ademas incrementa el contador del buffer en 1.
1088 Ademas incrementa el contador del buffer en 1.
1091
1089
1092 Return:
1090 Return:
1093 data : retorna un perfil de voltages (alturas * canales) copiados desde el
1091 data : retorna un perfil de voltages (alturas * canales) copiados desde el
1094 buffer. Si no hay mas archivos a leer retorna None.
1092 buffer. Si no hay mas archivos a leer retorna None.
1095
1093
1096 Variables afectadas:
1094 Variables afectadas:
1097 self.m_Voltage
1095 self.m_Voltage
1098 self.__datablockIndex
1096 self.__datablockIndex
1099 self.idProfile
1097 self.idProfile
1100
1098
1101 Affected:
1099 Affected:
1102 self.m_Voltage
1100 self.m_Voltage
1103 self.__datablockIndex
1101 self.__datablockIndex
1104 self.flagResetProcessing
1102 self.flagResetProcessing
1105 self.flagIsNewBlock
1103 self.flagIsNewBlock
1106 self.idProfile
1104 self.idProfile
1107 """
1105 """
1108 if self.noMoreFiles: return 0
1106 if self.noMoreFiles: return 0
1109
1107
1110 self.flagResetProcessing = 0
1108 self.flagResetProcessing = 0
1111 self.flagIsNewBlock = 0
1109 self.flagIsNewBlock = 0
1112
1110
1113 if self.__hasNotDataInBuffer():
1111 if self.__hasNotDataInBuffer():
1114
1112
1115 if not( self.readNextBlock() ):
1113 if not( self.readNextBlock() ):
1116 self.__setNextFile()
1114 self.__setNextFile()
1117 return 0
1115 return 0
1118
1116
1119 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
1117 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
1120 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1118 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1121 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1119 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1122 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
1120 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
1123 self.m_Voltage.heights = self.__heights
1121 self.m_Voltage.heights = self.__heights
1124 self.m_Voltage.dataType = self.__dataType
1122 self.m_Voltage.dataType = self.__dataType
1125
1123
1126 if self.noMoreFiles == 1:
1124 if self.noMoreFiles == 1:
1127 print 'Process finished'
1125 print 'Process finished'
1128 return 0
1126 return 0
1129
1127
1130 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1128 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1131
1129
1132 if self.datablock == None:
1130 if self.datablock == None:
1133 self.m_Voltage.flagNoData = True
1131 self.m_Voltage.flagNoData = True
1134 return 0
1132 return 0
1135
1133
1136 time = self.m_BasicHeader.utc + self.__datablockIndex * self.__ippSeconds
1134 time = self.m_BasicHeader.utc + self.__datablockIndex * self.__ippSeconds
1137 self.__utc = time
1135 self.__utc = time
1138 #self.m_Voltage.m_BasicHeader.utc = time
1136 #self.m_Voltage.m_BasicHeader.utc = time
1139
1137
1140 self.m_Voltage.flagNoData = False
1138 self.m_Voltage.flagNoData = False
1141 self.m_Voltage.flagResetProcessing = self.flagResetProcessing
1139 self.m_Voltage.flagResetProcessing = self.flagResetProcessing
1142
1140
1143 self.m_Voltage.data = self.datablock[self.__datablockIndex,:,:]
1141 self.m_Voltage.data = self.datablock[self.__datablockIndex,:,:]
1144 self.m_Voltage.idProfile = self.idProfile
1142 self.m_Voltage.idProfile = self.idProfile
1145
1143
1146 self.__datablockIndex += 1
1144 self.__datablockIndex += 1
1147 self.idProfile += 1
1145 self.idProfile += 1
1148
1146
1149 #call setData - to Data Object
1147 #call setData - to Data Object
1150
1148
1151 return 1 #self.m_Voltage.data
1149 return 1 #self.m_Voltage.data
1152
1150
1153
1151 class VoltageWriter( JRODataWriter ):
1154 class VoltageWriter(DataWriter):
1155 """
1152 """
1156 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
1153 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
1157 de los datos siempre se realiza por bloques.
1154 de los datos siempre se realiza por bloques.
1158 """
1155 """
1159 __configHeaderFile = 'wrSetHeadet.txt'
1156 __configHeaderFile = 'wrSetHeadet.txt'
1160
1157
1161 def __init__(self,m_Voltage=None):
1158 def __init__(self,m_Voltage=None):
1162 """
1159 """
1163 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
1160 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
1164
1161
1165 Affected:
1162 Affected:
1166 self.m_Voltage
1163 self.m_Voltage
1167 self.m_BasicHeader
1164 self.m_BasicHeader
1168 self.m_SystemHeader
1165 self.m_SystemHeader
1169 self.m_RadarControllerHeader
1166 self.m_RadarControllerHeader
1170 self.m_ProcessingHeader
1167 self.m_ProcessingHeader
1171
1168
1172 Return: None
1169 Return: None
1173 """
1170 """
1174 if m_Voltage == None:
1171 if m_Voltage == None:
1175 m_Voltage = Voltage()
1172 m_Voltage = Voltage()
1176
1173
1177 self.m_Voltage = m_Voltage
1174 self.m_Voltage = m_Voltage
1178
1175
1179 self.__path = None
1176 self.__path = None
1180
1177
1181 self.__fp = None
1178 self.__fp = None
1182
1179
1183 self.__format = None
1180 self.__format = None
1184
1181
1185 self.__blocksCounter = 0
1182 self.__blocksCounter = 0
1186
1183
1187 self.__setFile = None
1184 self.__setFile = None
1188
1185
1189 self.__flagIsNewFile = 1
1186 self.__flagIsNewFile = 1
1190
1187
1191 self.datablock = None
1188 self.datablock = None
1192
1189
1193 self.__datablockIndex = 0
1190 self.__datablockIndex = 0
1194
1191
1195 self.__dataType = None
1192 self.__dataType = None
1196
1193
1197 self.__ext = None
1194 self.__ext = None
1198
1195
1199 self.__shapeBuffer = None
1196 self.__shapeBuffer = None
1200
1197
1201 self.nWriteBlocks = 0
1198 self.nWriteBlocks = 0
1202
1199
1203 self.flagIsNewBlock = 0
1200 self.flagIsNewBlock = 0
1204
1201
1205 self.noMoreFiles = 0
1202 self.noMoreFiles = 0
1206
1203
1207 self.filename = None
1204 self.filename = None
1208
1205
1209 self.m_BasicHeader= BasicHeader()
1206 self.m_BasicHeader= BasicHeader()
1210
1207
1211 self.m_SystemHeader = SystemHeader()
1208 self.m_SystemHeader = SystemHeader()
1212
1209
1213 self.m_RadarControllerHeader = RadarControllerHeader()
1210 self.m_RadarControllerHeader = RadarControllerHeader()
1214
1211
1215 self.m_ProcessingHeader = ProcessingHeader()
1212 self.m_ProcessingHeader = ProcessingHeader()
1216
1213
1217
1214
1218 def __writeFirstHeader(self):
1215 def __writeFirstHeader(self):
1219 """
1216 """
1220 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1217 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1221
1218
1222 Affected:
1219 Affected:
1223 __dataType
1220 __dataType
1224
1221
1225 Return:
1222 Return:
1226 None
1223 None
1227 """
1224 """
1228 self.__writeBasicHeader()
1225 self.__writeBasicHeader()
1229 self.__wrSystemHeader()
1226 self.__wrSystemHeader()
1230 self.__wrRadarControllerHeader()
1227 self.__wrRadarControllerHeader()
1231 self.__wrProcessingHeader()
1228 self.__wrProcessingHeader()
1232 self.__dataType = self.m_Voltage.dataType
1229 self.__dataType = self.m_Voltage.dataType
1233
1230
1234
1231
1235 def __writeBasicHeader(self,fp=None):
1232 def __writeBasicHeader(self,fp=None):
1236 """
1233 """
1237 Escribe solo el Basic header en el file creado
1234 Escribe solo el Basic header en el file creado
1238
1235
1239 Return:
1236 Return:
1240 None
1237 None
1241 """
1238 """
1242 if fp == None:
1239 if fp == None:
1243 fp = self.__fp
1240 fp = self.__fp
1244
1241
1245 self.m_BasicHeader.write(fp)
1242 self.m_BasicHeader.write(fp)
1246
1243
1247
1244
1248 def __wrSystemHeader(self,fp=None):
1245 def __wrSystemHeader(self,fp=None):
1249 """
1246 """
1250 Escribe solo el System header en el file creado
1247 Escribe solo el System header en el file creado
1251
1248
1252 Return:
1249 Return:
1253 None
1250 None
1254 """
1251 """
1255 if fp == None:
1252 if fp == None:
1256 fp = self.__fp
1253 fp = self.__fp
1257
1254
1258 self.m_SystemHeader.write(fp)
1255 self.m_SystemHeader.write(fp)
1259
1256
1260
1257
1261 def __wrRadarControllerHeader(self,fp=None):
1258 def __wrRadarControllerHeader(self,fp=None):
1262 """
1259 """
1263 Escribe solo el RadarController header en el file creado
1260 Escribe solo el RadarController header en el file creado
1264
1261
1265 Return:
1262 Return:
1266 None
1263 None
1267 """
1264 """
1268 if fp == None:
1265 if fp == None:
1269 fp = self.__fp
1266 fp = self.__fp
1270
1267
1271 self.m_RadarControllerHeader.write(fp)
1268 self.m_RadarControllerHeader.write(fp)
1272
1269
1273
1270
1274 def __wrProcessingHeader(self,fp=None):
1271 def __wrProcessingHeader(self,fp=None):
1275 """
1272 """
1276 Escribe solo el Processing header en el file creado
1273 Escribe solo el Processing header en el file creado
1277
1274
1278 Return:
1275 Return:
1279 None
1276 None
1280 """
1277 """
1281 if fp == None:
1278 if fp == None:
1282 fp = self.__fp
1279 fp = self.__fp
1283
1280
1284 self.m_ProcessingHeader.write(fp)
1281 self.m_ProcessingHeader.write(fp)
1285
1282
1286
1283
1287 def __setNextFile(self):
1284 def __setNextFile(self):
1288 """
1285 """
1289 Determina el siguiente file que sera escrito
1286 Determina el siguiente file que sera escrito
1290
1287
1291 Affected:
1288 Affected:
1292 self.filename
1289 self.filename
1293 self.__subfolder
1290 self.__subfolder
1294 self.__fp
1291 self.__fp
1295 self.__setFile
1292 self.__setFile
1296 self.__flagIsNewFile
1293 self.__flagIsNewFile
1297
1294
1298 Return:
1295 Return:
1299 0 : Si el archivo no puede ser escrito
1296 0 : Si el archivo no puede ser escrito
1300 1 : Si el archivo esta listo para ser escrito
1297 1 : Si el archivo esta listo para ser escrito
1301 """
1298 """
1302 #setFile = self.__setFile
1299 #setFile = self.__setFile
1303 ext = self.__ext
1300 ext = self.__ext
1304 path = self.__path
1301 path = self.__path
1305
1302
1306 #setFile += 1
1303 #setFile += 1
1307
1304
1308 if self.__fp != None:
1305 if self.__fp != None:
1309 self.__fp.close()
1306 self.__fp.close()
1310
1307
1311 """
1308 """
1312 timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
1309 timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
1313 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext)
1310 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext)
1314 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1311 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1315 tmp = os.path.join(path,subfolder)
1312 tmp = os.path.join(path,subfolder)
1316 if not(os.path.exists(tmp)):
1313 if not(os.path.exists(tmp)):
1317 os.mkdir(tmp)
1314 os.mkdir(tmp)
1318 """
1315 """
1319 ##################################
1316 ##################################
1320 """
1317 """
1321 if self.m_BasicHeader.size <= 24:
1318 if self.m_BasicHeader.size <= 24:
1322 self.__fp.close()
1319 self.__fp.close()
1323 self.__fp = None
1320 self.__fp = None
1324 return 0 #no existe la suficiente data para ser escrita
1321 return 0 #no existe la suficiente data para ser escrita
1325 """
1322 """
1326
1323
1327 timeTuple = time.localtime( self.m_Voltage.m_BasicHeader.utc ) # utc from m_Voltage
1324 timeTuple = time.localtime( self.m_Voltage.m_BasicHeader.utc ) # utc from m_Voltage
1328 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1325 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1329
1326
1330 tmp = os.path.join( path, subfolder )
1327 tmp = os.path.join( path, subfolder )
1331 if not( os.path.exists(tmp) ):
1328 if not( os.path.exists(tmp) ):
1332 os.mkdir(tmp)
1329 os.mkdir(tmp)
1333 self.__setFile = -1 #inicializo mi contador de seteo
1330 self.__setFile = -1 #inicializo mi contador de seteo
1334 else:
1331 else:
1335 filesList = os.listdir( tmp )
1332 filesList = os.listdir( tmp )
1336 if len( filesList ) > 0:
1333 if len( filesList ) > 0:
1337 filesList = sorted( filesList, key=str.lower )
1334 filesList = sorted( filesList, key=str.lower )
1338 filen = filesList[-1]
1335 filen = filesList[-1]
1339 # el filename debera tener el siguiente formato
1336 # el filename debera tener el siguiente formato
1340 # 0 1234 567 89A BCDE (hex)
1337 # 0 1234 567 89A BCDE (hex)
1341 # D YYYY DDD SSS .ext
1338 # D YYYY DDD SSS .ext
1342 if isNumber( filen[8:11] ):
1339 if isNumber( filen[8:11] ):
1343 self.__setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1340 self.__setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1344 else:
1341 else:
1345 self.__setFile = -1
1342 self.__setFile = -1
1346 else:
1343 else:
1347 self.__setFile = -1 #inicializo mi contador de seteo
1344 self.__setFile = -1 #inicializo mi contador de seteo
1348
1345
1349 setFile = self.__setFile
1346 setFile = self.__setFile
1350 setFile += 1
1347 setFile += 1
1351 file = 'D%4.4d%3.3d%3.3d%s' % ( timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
1348 file = 'D%4.4d%3.3d%3.3d%s' % ( timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
1352 ##################################
1349 ##################################
1353
1350
1354 filename = os.path.join( path, subfolder, file )
1351 filename = os.path.join( path, subfolder, file )
1355
1352
1356 fp = open( filename,'wb' )
1353 fp = open( filename,'wb' )
1357
1354
1358 self.__blocksCounter = 0
1355 self.__blocksCounter = 0
1359
1356
1360 #guardando atributos
1357 #guardando atributos
1361 self.filename = filename
1358 self.filename = filename
1362 self.__subfolder = subfolder
1359 self.__subfolder = subfolder
1363 self.__fp = fp
1360 self.__fp = fp
1364 self.__setFile = setFile
1361 self.__setFile = setFile
1365 self.__flagIsNewFile = 1
1362 self.__flagIsNewFile = 1
1366
1363
1367 print 'Writing the file: %s'%self.filename
1364 print 'Writing the file: %s'%self.filename
1368
1365
1369 self.__writeFirstHeader()
1366 self.__writeFirstHeader()
1370
1367
1371 return 1
1368 return 1
1372
1369
1373
1370
1374 def __setNewBlock(self):
1371 def __setNewBlock(self):
1375 """
1372 """
1376 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1373 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1377
1374
1378 Return:
1375 Return:
1379 0 : si no pudo escribir nada
1376 0 : si no pudo escribir nada
1380 1 : Si escribio el Basic el First Header
1377 1 : Si escribio el Basic el First Header
1381 """
1378 """
1382 if self.__fp == None:
1379 if self.__fp == None:
1383 self.__setNextFile()
1380 self.__setNextFile()
1384
1381
1385 if self.__flagIsNewFile:
1382 if self.__flagIsNewFile:
1386 return 1
1383 return 1
1387
1384
1388 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1385 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1389 self.__writeBasicHeader()
1386 self.__writeBasicHeader()
1390 return 1
1387 return 1
1391
1388
1392 if not( self.__setNextFile() ):
1389 if not( self.__setNextFile() ):
1393 return 0
1390 return 0
1394
1391
1395 return 1
1392 return 1
1396
1393
1397
1394
1398 def __writeBlock(self):
1395 def __writeBlock(self):
1399 """
1396 """
1400 Escribe el buffer en el file designado
1397 Escribe el buffer en el file designado
1401
1398
1402 Affected:
1399 Affected:
1403 self.__datablockIndex
1400 self.__datablockIndex
1404 self.__flagIsNewFile
1401 self.__flagIsNewFile
1405 self.flagIsNewBlock
1402 self.flagIsNewBlock
1406 self.nWriteBlocks
1403 self.nWriteBlocks
1407 self.__blocksCounter
1404 self.__blocksCounter
1408
1405
1409 Return: None
1406 Return: None
1410 """
1407 """
1411 data = numpy.zeros( self.__shapeBuffer, self.__dataType )
1408 data = numpy.zeros( self.__shapeBuffer, self.__dataType )
1412
1409
1413 data['real'] = self.datablock.real
1410 data['real'] = self.datablock.real
1414 data['imag'] = self.datablock.imag
1411 data['imag'] = self.datablock.imag
1415
1412
1416 data = data.reshape( (-1) )
1413 data = data.reshape( (-1) )
1417
1414
1418 data.tofile( self.__fp )
1415 data.tofile( self.__fp )
1419
1416
1420 self.datablock.fill(0)
1417 self.datablock.fill(0)
1421 self.__datablockIndex = 0
1418 self.__datablockIndex = 0
1422 self.__flagIsNewFile = 0
1419 self.__flagIsNewFile = 0
1423 self.flagIsNewBlock = 1
1420 self.flagIsNewBlock = 1
1424 self.nWriteBlocks += 1
1421 self.nWriteBlocks += 1
1425 self.__blocksCounter += 1
1422 self.__blocksCounter += 1
1426
1423
1427
1424
1428 def writeNextBlock(self):
1425 def writeNextBlock(self):
1429 """
1426 """
1430 Selecciona el bloque siguiente de datos y los escribe en un file
1427 Selecciona el bloque siguiente de datos y los escribe en un file
1431
1428
1432 Return:
1429 Return:
1433 0 : Si no hizo pudo escribir el bloque de datos
1430 0 : Si no hizo pudo escribir el bloque de datos
1434 1 : Si no pudo escribir el bloque de datos
1431 1 : Si no pudo escribir el bloque de datos
1435 """
1432 """
1436 if not(self.__setNewBlock()):
1433 if not(self.__setNewBlock()):
1437 return 0
1434 return 0
1438
1435
1439 self.__writeBlock()
1436 self.__writeBlock()
1440 return 1
1437 return 1
1441
1438
1442
1439
1443 def __hasAllDataInBuffer(self):
1440 def __hasAllDataInBuffer(self):
1444 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
1441 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
1445 return 1
1442 return 1
1446 return 0
1443 return 0
1447
1444
1448
1445
1449 def putData(self):
1446 def putData(self):
1450 """
1447 """
1451 Setea un bloque de datos y luego los escribe en un file
1448 Setea un bloque de datos y luego los escribe en un file
1452
1449
1453 Affected:
1450 Affected:
1454 self.flagIsNewBlock
1451 self.flagIsNewBlock
1455 self.__datablockIndex
1452 self.__datablockIndex
1456
1453
1457 Return:
1454 Return:
1458 0 : Si no hay data o no hay mas files que puedan escribirse
1455 0 : Si no hay data o no hay mas files que puedan escribirse
1459 1 : Si se escribio la data de un bloque en un file
1456 1 : Si se escribio la data de un bloque en un file
1460 """
1457 """
1461 self.flagIsNewBlock = 0
1458 self.flagIsNewBlock = 0
1462
1459
1463 if self.m_Voltage.flagNoData:
1460 if self.m_Voltage.flagNoData:
1464 return 0
1461 return 0
1465
1462
1466 if self.m_Voltage.flagResetProcessing:
1463 if self.m_Voltage.flagResetProcessing:
1467
1464
1468 self.datablock.fill(0)
1465 self.datablock.fill(0)
1469 self.__datablockIndex = 0
1466 self.__datablockIndex = 0
1470 self.__setNextFile()
1467 self.__setNextFile()
1471
1468
1472 self.datablock[self.__datablockIndex,:,:] = self.m_Voltage.data
1469 self.datablock[self.__datablockIndex,:,:] = self.m_Voltage.data
1473
1470
1474 self.__datablockIndex += 1
1471 self.__datablockIndex += 1
1475
1472
1476 if self.__hasAllDataInBuffer():
1473 if self.__hasAllDataInBuffer():
1477 self.__getHeader()
1474 self.__getHeader()
1478 self.writeNextBlock()
1475 self.writeNextBlock()
1479
1476
1480 if self.noMoreFiles:
1477 if self.noMoreFiles:
1481 #print 'Process finished'
1478 #print 'Process finished'
1482 return 0
1479 return 0
1483
1480
1484 return 1
1481 return 1
1485
1482
1486
1483
1487 def __getHeader(self):
1484 def __getHeader(self):
1488 """
1485 """
1489 Obtiene una copia del First Header
1486 Obtiene una copia del First Header
1490
1487
1491 Affected:
1488 Affected:
1492 self.m_BasicHeader
1489 self.m_BasicHeader
1493 self.m_SystemHeader
1490 self.m_SystemHeader
1494 self.m_RadarControllerHeader
1491 self.m_RadarControllerHeader
1495 self.m_ProcessingHeader
1492 self.m_ProcessingHeader
1496 self.__dataType
1493 self.__dataType
1497
1494
1498 Return:
1495 Return:
1499 None
1496 None
1500 """
1497 """
1501 self.m_BasicHeader = self.m_Voltage.m_BasicHeader.copy()
1498 self.m_BasicHeader = self.m_Voltage.m_BasicHeader.copy()
1502 self.m_SystemHeader = self.m_Voltage.m_SystemHeader.copy()
1499 self.m_SystemHeader = self.m_Voltage.m_SystemHeader.copy()
1503 self.m_RadarControllerHeader = self.m_Voltage.m_RadarControllerHeader.copy()
1500 self.m_RadarControllerHeader = self.m_Voltage.m_RadarControllerHeader.copy()
1504 self.m_ProcessingHeader = self.m_Voltage.m_ProcessingHeader.copy()
1501 self.m_ProcessingHeader = self.m_Voltage.m_ProcessingHeader.copy()
1505 self.__dataType = self.m_Voltage.dataType
1502 self.__dataType = self.m_Voltage.dataType
1506
1503
1507
1504
1508 def __setHeaderByFile(self):
1505 def __setHeaderByFile(self):
1509
1506
1510 format = self.__format
1507 format = self.__format
1511 header = ['Basic','System','RadarController','Processing']
1508 header = ['Basic','System','RadarController','Processing']
1512
1509
1513 fmtFromFile = None
1510 fmtFromFile = None
1514 headerFromFile = None
1511 headerFromFile = None
1515
1512
1516
1513
1517 fileTable = self.__configHeaderFile
1514 fileTable = self.__configHeaderFile
1518
1515
1519 if os.access(fileTable, os.R_OK):
1516 if os.access(fileTable, os.R_OK):
1520 import re, string
1517 import re, string
1521
1518
1522 f = open(fileTable,'r')
1519 f = open(fileTable,'r')
1523 lines = f.read()
1520 lines = f.read()
1524 f.close()
1521 f.close()
1525
1522
1526 #Delete comments into expConfig
1523 #Delete comments into expConfig
1527 while 1:
1524 while 1:
1528
1525
1529 startComment = string.find(lines.lower(),'#')
1526 startComment = string.find(lines.lower(),'#')
1530 if startComment == -1:
1527 if startComment == -1:
1531 break
1528 break
1532 endComment = string.find(lines.lower(),'\n',startComment)
1529 endComment = string.find(lines.lower(),'\n',startComment)
1533 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
1530 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
1534
1531
1535 while expFromFile == None:
1532 while expFromFile == None:
1536
1533
1537 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
1534 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
1538 nextFmt = string.find(lines.lower(),'format',currFmt+10)
1535 nextFmt = string.find(lines.lower(),'format',currFmt+10)
1539
1536
1540 if currFmt == -1:
1537 if currFmt == -1:
1541 break
1538 break
1542 if nextFmt == -1:
1539 if nextFmt == -1:
1543 nextFmt = len(lines)-1
1540 nextFmt = len(lines)-1
1544
1541
1545 fmtTable = lines[currFmt:nextFmt]
1542 fmtTable = lines[currFmt:nextFmt]
1546 lines = lines[nextFmt:]
1543 lines = lines[nextFmt:]
1547
1544
1548 fmtRead = self.__getValueFromArg(fmtTable,'format')
1545 fmtRead = self.__getValueFromArg(fmtTable,'format')
1549 if fmtRead != format:
1546 if fmtRead != format:
1550 continue
1547 continue
1551 fmtFromFile = fmtRead
1548 fmtFromFile = fmtRead
1552
1549
1553 lines2 = fmtTable
1550 lines2 = fmtTable
1554
1551
1555 while headerFromFile == None:
1552 while headerFromFile == None:
1556
1553
1557 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
1554 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
1558 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
1555 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
1559
1556
1560 if currHeader == -1:
1557 if currHeader == -1:
1561 break
1558 break
1562 if nextHeader == -1:
1559 if nextHeader == -1:
1563 nextHeader = len(lines2)-1
1560 nextHeader = len(lines2)-1
1564
1561
1565 headerTable = lines2[currHeader:nextHeader]
1562 headerTable = lines2[currHeader:nextHeader]
1566 lines2 = lines2[nextHeader:]
1563 lines2 = lines2[nextHeader:]
1567
1564
1568 headerRead = self.__getValueFromArg(headerTable,'site')
1565 headerRead = self.__getValueFromArg(headerTable,'site')
1569 if not(headerRead in header):
1566 if not(headerRead in header):
1570 continue
1567 continue
1571 headerFromFile = headerRead
1568 headerFromFile = headerRead
1572
1569
1573 if headerRead == 'Basic':
1570 if headerRead == 'Basic':
1574 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
1571 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
1575 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
1572 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
1576 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
1573 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
1577 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
1574 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
1578 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
1575 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
1579 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
1576 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
1580 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
1577 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
1581 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
1578 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
1582
1579
1583 else:
1580 else:
1584 print "file access denied:%s"%fileTable
1581 print "file access denied:%s"%fileTable
1585 sys.exit(0)
1582 sys.exit(0)
1586
1583
1587
1584
1588 def setup(self,path,set=0,format='rawdata'):
1585 def setup(self,path,set=0,format='rawdata'):
1589 """
1586 """
1590 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1587 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1591
1588
1592 Inputs:
1589 Inputs:
1593 path : el path destino en el cual se escribiran los files a crear
1590 path : el path destino en el cual se escribiran los files a crear
1594 format : formato en el cual sera salvado un file
1591 format : formato en el cual sera salvado un file
1595 set : el setebo del file
1592 set : el setebo del file
1596
1593
1597 Return:
1594 Return:
1598 0 : Si no realizo un buen seteo
1595 0 : Si no realizo un buen seteo
1599 1 : Si realizo un buen seteo
1596 1 : Si realizo un buen seteo
1600 """
1597 """
1601 if format == 'hdf5':
1598 if format == 'hdf5':
1602 ext = '.hdf5'
1599 ext = '.hdf5'
1603 format = 'hdf5'
1600 format = 'hdf5'
1604 print 'call hdf5 library'
1601 print 'call hdf5 library'
1605 return 0
1602 return 0
1606
1603
1607 if format == 'rawdata':
1604 if format == 'rawdata':
1608 ext = '.r'
1605 ext = '.r'
1609 format = 'Jicamarca'
1606 format = 'Jicamarca'
1610
1607
1611 #call to config_headers
1608 #call to config_headers
1612 #self.__setHeaderByFile()
1609 #self.__setHeaderByFile()
1613
1610
1614 self.__path = path
1611 self.__path = path
1615 self.__setFile = set - 1
1612 self.__setFile = set - 1
1616 self.__ext = ext
1613 self.__ext = ext
1617 self.__format = format
1614 self.__format = format
1618
1615
1619 self.__getHeader()
1616 self.__getHeader()
1620 self.__shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
1617 self.__shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
1621 self.m_ProcessingHeader.numHeights,
1618 self.m_ProcessingHeader.numHeights,
1622 self.m_SystemHeader.numChannels )
1619 self.m_SystemHeader.numChannels )
1623
1620
1624 self.datablock = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex'))
1621 self.datablock = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex'))
1625
1622
1626 if not( self.__setNextFile() ):
1623 if not( self.__setNextFile() ):
1627 return 0
1624 return 0
1628
1625
1629 return 1
1626 return 1
1630
1627
1631
1628
1632
1629
1633
1630
1634 No newline at end of file
1631
Show file before | Show file after | Hide comments
1 NO CONTENT: file was removed
NO CONTENT: file was removed
General Comments 0
You need to be logged in to leave comments. Login now