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