##// END OF EJS Templates
schain
RSS
Cambios realiazados en busqueda de datos online y offline, en el metodo JRODataReader.setup se han definido los parametros: startDate, endDate, startTime, endTime. Todos estos cambios fueron realizado en el Archivo JRODataIO.py
Daniel Valdez -
r117:aee4019df37c
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1236 +1,1266
1 1 '''
2 2 Created on 23/01/2012
3 3
4 4 @author $Author$
5 5 @version $Id$
6 6 @version $Id$
7 7 '''
8 8
9 9 import os, sys
10 10 import glob
11 11 import time
12 12 import numpy
13 13 import fnmatch
14 14 import time, datetime
15 15
16 16 path = os.path.split(os.getcwd())[0]
17 17 sys.path.append(path)
18 18
19 19 from Model.JROHeader import *
20 20 from Model.JROData import JROData
21 21
22 22 def checkForRealPath(path, year, doy, set, ext):
23 23 """
24 24 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
25 25 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
26 26 el path exacto de un determinado file.
27 27
28 28 Example :
29 29 nombre correcto del file es .../.../D2009307/P2009307367.ext
30 30
31 31 Entonces la funcion prueba con las siguientes combinaciones
32 32 .../.../x2009307/y2009307367.ext
33 33 .../.../x2009307/Y2009307367.ext
34 34 .../.../X2009307/y2009307367.ext
35 35 .../.../X2009307/Y2009307367.ext
36 36 siendo para este caso, la ultima combinacion de letras, identica al file buscado
37 37
38 38 Return:
39 39 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
40 40 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
41 41 para el filename
42 42 """
43 43 filepath = None
44 44 find_flag = False
45 45 filename = None
46 46
47 47 if ext.lower() == ".r": #voltage
48 48 header1 = "dD"
49 49 header2 = "dD"
50 50 elif ext.lower() == ".pdata": #spectra
51 51 header1 = "dD"
52 52 header2 = "pP"
53 53 else:
54 54 return None, filename
55 55
56 56 for dir in header1: #barrido por las dos combinaciones posibles de "D"
57 57 for fil in header2: #barrido por las dos combinaciones posibles de "D"
58 58 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
59 59 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
60 60 filepath = os.path.join( path, doypath, filename ) #formo el path completo
61 61 if os.path.exists( filepath ): #verifico que exista
62 62 find_flag = True
63 63 break
64 64 if find_flag:
65 65 break
66 66
67 67 if not(find_flag):
68 68 return None, filename
69 69
70 70 return filepath, filename
71 71
72 72
73 73 def isNumber(str):
74 74 """
75 75 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
76 76
77 77 Excepciones:
78 78 Si un determinado string no puede ser convertido a numero
79 79 Input:
80 80 str, string al cual se le analiza para determinar si convertible a un numero o no
81 81
82 82 Return:
83 83 True : si el string es uno numerico
84 84 False : no es un string numerico
85 85 """
86 86 try:
87 87 float( str )
88 88 return True
89 89 except:
90 90 return False
91 91
92 92
93 93 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
94 94 """
95 95 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
96 96
97 97 Inputs:
98 98 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
99 99
100 100 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
101 101 segundos contados desde 01/01/1970.
102 102 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
103 103 segundos contados desde 01/01/1970.
104 104
105 105 Return:
106 106 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
107 107 fecha especificado, de lo contrario retorna False.
108 108
109 109 Excepciones:
110 110 Si el archivo no existe o no puede ser abierto
111 111 Si la cabecera no puede ser leida.
112 112
113 113 """
114 114 m_BasicHeader = BasicHeader()
115 115
116 116 try:
117 117 fp = open(filename,'rb')
118 118 except:
119 119 raise IOError, "The file %s can't be opened" %(filename)
120 120
121 121 sts = m_BasicHeader.read(fp)
122 122 fp.close()
123 123
124 124 if not(sts):
125 125 print "Skipping the file %s because it has not a valid header" %(filename)
126 126 return 0
127 127
128 128 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds > m_BasicHeader.utc)):
129 129 return 0
130 130
131 131 return 1
132 132
133 133
134 134 def getlastFileFromPath(path, ext):
135 135 """
136 136 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
137 137 al final de la depuracion devuelve el ultimo file de la lista que quedo.
138 138
139 139 Input:
140 140 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
141 141 ext : extension de los files contenidos en una carpeta
142 142
143 143 Return:
144 144 El ultimo file de una determinada carpeta, no se considera el path.
145 145 """
146 146 validFilelist = []
147 147 fileList = os.listdir(path)
148 148
149 149 # 0 1234 567 89A BCDE
150 150 # H YYYY DDD SSS .ext
151 151
152 152 for file in fileList:
153 153 try:
154 154 year = int(file[1:5])
155 155 doy = int(file[5:8])
156 156
157 157 if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue
158 158 except:
159 159 continue
160 160
161 161 validFilelist.append(file)
162 162
163 163 if validFilelist:
164 164 validFilelist = sorted( validFilelist, key=str.lower )
165 165 return validFilelist[-1]
166 166
167 167 return None
168 168
169 169 class JRODataIO:
170 170
171 171 #speed of light
172 172 c = 3E8
173 173
174 174 m_BasicHeader = BasicHeader()
175 175
176 176 m_SystemHeader = SystemHeader()
177 177
178 178 m_RadarControllerHeader = RadarControllerHeader()
179 179
180 180 m_ProcessingHeader = ProcessingHeader()
181 181
182 182 dataOutObj = None
183 183
184 184 online = 0
185 185
186 186 fp = None
187 187
188 188 dataType = None
189 189
190 190 fileSizeByHeader = None
191 191
192 192 filenameList = []
193 193
194 194 filename = None
195 195
196 196 fileSize = None
197 197
198 198 firstHeaderSize = 0
199 199
200 200 basicHeaderSize = 24
201 201
202 202 nTotalBlocks = 0
203 203
204 204 ippSeconds = 0
205 205
206 206 blocksize = 0
207 207
208 208 set = 0
209 209
210 210 ext = None
211 211
212 212 path = None
213 213
214 214 maxTimeStep = 30
215 215
216 216
217 217 delay = 3 #seconds
218 218
219 219 nTries = 3 #quantity tries
220 220
221 221 nFiles = 3 #number of files for searching
222 222
223 223
224 224 flagNoMoreFiles = 0
225 225
226 226 flagIsNewFile = 1
227 227
228 228 flagResetProcessing = 0
229 229
230 230 flagIsNewBlock = 0
231 231
232 232 def __init__(self):
233 233 pass
234 234
235 235 class JRODataReader(JRODataIO):
236 236
237 237 """
238 238 Esta clase es usada como la clase padre de las clases VoltageReader y SpectraReader.
239 239 Contiene todos lo metodos necesarios para leer datos desde archivos en formato
240 240 jicamarca o pdata (.r o .pdata). La lectura de los datos siempre se realiza por bloques. Los datos
241 241 leidos son array de 3 dimensiones:
242 242
243 243 Para Voltajes - perfiles * alturas * canales
244 244
245 245 Para Spectra - paresCanalesIguales * alturas * perfiles (Self Spectra)
246 246 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
247 247 canales * alturas (DC Channels)
248 248
249 249 y son almacenados en su buffer respectivo.
250 250
251 251 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
252 252 RadarControllerHeader y DataObj. Los tres primeros se usan para almacenar informacion de la
253 253 cabecera de datos (metadata), y el cuarto (DataObj) para obtener y almacenar los datos desde
254 254 el buffer de datos cada vez que se ejecute el metodo "getData".
255 255 """
256 256
257 257 nReadBlocks = 0
258 258
259 259 def __init__(self, dataOutObj=None):
260 260
261 261 raise ValueError, "This class can't be instanced"
262 262
263 263
264 264 def hasNotDataInBuffer(self):
265 265
266 266 raise ValueError, "Not implemented"
267 267
268 268 def getBlockDimension(self):
269 269
270 270 raise ValueError, "No implemented"
271 271
272 272 def readBlock(self):
273 273
274 274 self.nTotalBlocks += 1
275 275 self.nReadBlocks += 1
276 276
277 277 raise ValueError, "This method has not been implemented"
278 278
279 279 def getData( self ):
280 280
281 281 raise ValueError, "This method has not been implemented"
282 282
283 283 def createObjByDefault(self):
284 284 """
285 285 Los objetos creados por defecto por cada clase (Voltaje o Espectro) difieren en el tipo
286 286 raise ValueError, "This method has not been implemented
287 287 """
288 288 raise ValueError, "This method has not been implemented"
289 289
290 290 # def setup(self, dataOutObj=None, path=None, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
291 def setup(self, dataOutObj=None, path=None, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
291
292 def __searchFilesOnLine(self, path, expLabel = "", ext = None, startDate=None, endDate=None, startTime=None, endTime=None):
293 """
294 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
295 devuelve el archivo encontrado ademas de otros datos.
296
297 Input:
298 path : carpeta donde estan contenidos los files que contiene data
299
300 startDate : Fecha inicial. Rechaza todos los directorios donde
301 file end time < startDate (obejto datetime.date)
302
303 endDate : Fecha final. Rechaza todos los directorios donde
304 file start time > endDate (obejto datetime.date)
305
306 startTime : Tiempo inicial. Rechaza todos los archivos donde
307 file end time < startTime (obejto datetime.time)
308
309 endTime : Tiempo final. Rechaza todos los archivos donde
310 file start time > endTime (obejto datetime.time)
311
312 ext : extension de los files
313
314 Return:
315 directory : eL directorio donde esta el file encontrado
316 filename : el ultimo file de una determinada carpeta
317 year : el anho
318 doy : el numero de dia del anho
319 set : el set del archivo
320
321
322 """
323 dirList = []
324 pathList = []
325 directory = None
326
327 #Filtra solo los directorios
328 for thisPath in os.listdir(path):
329 if os.path.isdir(os.path.join(path, thisPath)):
330 dirList.append(thisPath)
331
332 if not(dirList):
333 return None, None, None, None, None
334
335 dirList = sorted( dirList, key=str.lower )
336
337 if startDate:
338 startDateTime = datetime.datetime.combine(startDate, startTime)
339 thisDateTime = startDateTime
340 if endDate == None: endDateTime = startDateTime
341 else: endDateTime = datetime.datetime.combine(endDate, endTime)
342
343 while(thisDateTime <= endDateTime):
344 year = thisDateTime.timetuple().tm_year
345 doy = thisDateTime.timetuple().tm_yday
346
347 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
348 if len(match) == 0:
349 thisDateTime += datetime.timedelta(1)
350 continue
351
352 pathList.append(os.path.join(path,match[0], expLabel))
353 thisDateTime += datetime.timedelta(1)
354
355 if not(pathList):
356 print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
357 return None, None, None, None, None
358
359 directory = pathList[0]
360
361 else:
362 directory = dirList[-1]
363 directory = os.path.join(path,directory)
364
365 filename = getlastFileFromPath(directory, ext)
366
367 if not(filename):
368 return None, None, None, None, None
369
370 if not(self.__verifyFile(os.path.join(directory, filename))):
371 return None, None, None, None, None
372
373 year = int( filename[1:5] )
374 doy = int( filename[5:8] )
375 set = int( filename[8:11] )
376
377 return directory, filename, year, doy, set
378
379
380 def __searchFilesOffLine(self, path, startDate, endDate, startTime=datetime.time(0,0,0), endTime=datetime.time(23,59,59),set=None, expLabel = "", ext = ".r"):
381 """
382 Realiza una busqueda de los archivos que coincidan con los parametros
383 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
384 correcta la estructura de directorios debe ser la siguiente:
385
386 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
387
388 [yyyy]: anio
389 [ddd] : dia del anio
390 [sss] : set del archivo
391
392 Inputs:
393 path : Directorio de datos donde se realizara la busqueda. Todos los
394 ficheros que concidan con el criterio de busqueda seran
395 almacenados en una lista y luego retornados.
396 startDate : Fecha inicial. Rechaza todos los directorios donde
397 file end time < startDate (obejto datetime.date)
398
399 endDate : Fecha final. Rechaza todos los directorios donde
400 file start time > endDate (obejto datetime.date)
401
402 startTime : Tiempo inicial. Rechaza todos los archivos donde
403 file end time < startTime (obejto datetime.time)
404
405 endTime : Tiempo final. Rechaza todos los archivos donde
406 file start time > endTime (obejto datetime.time)
407
408 set : Set del primer archivo a leer. Por defecto None
409
410 expLabel : Nombre del subdirectorio de datos. Por defecto ""
411
412 ext : Extension de los archivos a leer. Por defecto .r
413
414 Return:
415
416 (pathList, filenameList)
417
418 pathList : Lista de directorios donde se encontraron archivos dentro
419 de los parametros especificados
420 filenameList : Lista de archivos (ruta completa) que coincidieron con los
421 parametros especificados.
422
423 Variables afectadas:
424
425 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
426 como fuente para leer los bloque de datos, si se termina
427 de leer todos los bloques de datos de un determinado
428 archivo se pasa al siguiente archivo de la lista.
429
430 Excepciones:
431
432 """
433
434 dirList = []
435 for thisPath in os.listdir(path):
436 if os.path.isdir(os.path.join(path,thisPath)):
437 dirList.append(thisPath)
438
439 if not(dirList):
440 return None, None
441
442 pathList = []
443 dateList = []
444
445 thisDate = startDate
446
447 while(thisDate <= endDate):
448 year = thisDate.timetuple().tm_year
449 doy = thisDate.timetuple().tm_yday
450
451 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
452 if len(match) == 0:
453 thisDate += datetime.timedelta(1)
454 continue
455
456 pathList.append(os.path.join(path,match[0],expLabel))
457 dateList.append(thisDate)
458 thisDate += datetime.timedelta(1)
459
460 filenameList = []
461 for index in range(len(pathList)):
462
463 thisPath = pathList[index]
464 fileList = glob.glob1(thisPath, "*%s" %ext)
465 fileList.sort()
466
467 #Busqueda de datos en el rango de horas indicados
468 thisDate = dateList[index]
469 startDT = datetime.datetime.combine(thisDate, startTime)
470 endDT = datetime.datetime.combine(thisDate, endTime)
471
472 startUtSeconds = time.mktime(startDT.timetuple())
473 endUtSeconds = time.mktime(endDT.timetuple())
474
475 for file in fileList:
476
477 filename = os.path.join(thisPath,file)
478
479 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
480 filenameList.append(filename)
481
482 if not(filenameList):
483 return None, None
484
485 self.filenameList = filenameList
486
487 return pathList, filenameList
488
489 def setup(self, dataOutObj=None, path=None, startDate=None, endDate=None, startTime=datetime.time(0,0,0), endTime=datetime.time(23,59,59), set=0, expLabel = "", ext = None, online = 0):
292 490 """
293 491 setup configura los parametros de lectura de la clase DataReader.
294 492
295 493 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
296 494 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
297 495 self.filenameList.
298 496
299 497 Input:
300 498 path : Directorios donde se ubican los datos a leer. Dentro de este
301 499 directorio deberia de estar subdirectorios de la forma:
302 500
303 501 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
304 502
305 startDateTime : Fecha inicial. Rechaza todos los archivos donde
306 file end time < startDatetime (obejto datetime.datetime)
503 startDate : Fecha inicial. Rechaza todos los directorios donde
504 file end time < startDate (obejto datetime.date)
505
506 endDate : Fecha final. Rechaza todos los directorios donde
507 file start time > endDate (obejto datetime.date)
307 508
308 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
309 file end time < startDatetime (obejto datetime.datetime)
509 startTime : Tiempo inicial. Rechaza todos los archivos donde
510 file end time < startTime (obejto datetime.time)
511
512 endTime : Tiempo final. Rechaza todos los archivos donde
513 file start time > endTime (obejto datetime.time)
310 514
311 515 set : Set del primer archivo a leer. Por defecto None
312 516
313 517 expLabel : Nombre del subdirectorio de datos. Por defecto ""
314 518
315 519 ext : Extension de los archivos a leer. Por defecto .r
316 520
317 521 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
318 522
319 523 Return:
320 524 0 : Si no encuentra files que cumplan con las condiciones dadas
321 525 1 : Si encuentra files que cumplan con las condiciones dadas
322 526
323 527 Affected:
324 self.startUTCSeconds
325 self.endUTCSeconds
326 528 self.startYear
327 529 self.endYear
328 530 self.startDoy
329 531 self.endDoy
330 532 self.pathList
331 533 self.filenameList
332 534 self.online
333 535 """
334 536 if path == None:
335 537 raise ValueError, "The path is not valid"
336 538
337 539 if ext == None:
338 540 ext = self.ext
339 541
340 542 if dataOutObj == None:
341 543 dataOutObj = self.createObjByDefault()
342 544
343 545 self.dataOutObj = dataOutObj
344 546
345 547 if online:
346 print "Searching files ..."
347 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
548 print "Searching files in online mode..."
549 doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=exp)
348 550
349 551 if not(doypath):
350 552 for nTries in range( self.nTries ):
351 553 print '\tWaiting %0.2f sec for valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
352 554 time.sleep( self.delay )
353 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
555 doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=exp)
354 556 if doypath:
355 557 break
356 558
357 559 if not(doypath):
358 560 print "There 'isn't valied files in %s" % path
359 561 return None
360 562
361 563 self.year = year
362 564 self.doy = doy
363 565 self.set = set - 1
364 566 self.path = path
365 567
366 568 else: # offline
367 pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext)
569 print "Searching files in offline mode..."
570 pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
368 571 if not(pathList):
369 572 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
370 573 return None
371 574
372 575 self.fileIndex = -1
373 576 self.pathList = pathList
374 577 self.filenameList = filenameList
375 578
376 579 self.online = online
377 580 self.ext = ext
378 581
379 582 ext = ext.lower()
380 583
381 584 if not( self.setNextFile() ):
382 if (startDateTime != None) and (endDateTime != None):
383 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
384 elif startDateTime != None:
385 print "No files in : %s" % startDateTime.ctime()
585 if (startDate != None) and (endDate != None):
586 print "No files in range: %s - %s" %(startDate.ctime(), endDate.ctime())
587 elif startDate != None:
588 print "No files in : %s" % startDate.ctime()
386 589 else:
387 590 print "No files"
388 591 return None
389 592
390 if startDateTime != None:
391 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
392 self.startYear = startDateTime.timetuple().tm_year
393 self.startDoy = startDateTime.timetuple().tm_yday
394
395 if endDateTime != None:
396 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
397 self.endYear = endDateTime.timetuple().tm_year
398 self.endDoy = endDateTime.timetuple().tm_yday
399 593 #call fillHeaderValues() - to Data Object
400 594
401 595 self.updateDataHeader()
402 596
403 597 return self.dataOutObj
404 598
405 599 def __rdSystemHeader(self, fp=None):
406 600
407 601 if fp == None:
408 602 fp = self.fp
409 603
410 604 self.m_SystemHeader.read(fp)
411 605
412 606
413 607 def __rdRadarControllerHeader(self, fp=None):
414 608 if fp == None:
415 609 fp = self.fp
416 610
417 611 self.m_RadarControllerHeader.read(fp)
418 612
419 613
420 614 def __rdProcessingHeader(self, fp=None):
421 615 if fp == None:
422 616 fp = self.fp
423 617
424 618 self.m_ProcessingHeader.read(fp)
425 619
426 620
427 621 def __rdBasicHeader(self, fp=None):
428 622
429 623 if fp == None:
430 624 fp = self.fp
431 625
432 626 self.m_BasicHeader.read(fp)
433 627
434 628 def __readFirstHeader(self):
435 629 """
436 630 Lectura del First Header, es decir el Basic Header y el Long Header
437 631
438 632 Affected:
439 633 self.m_BasicHeader
440 634 self.m_SystemHeader
441 635 self.m_RadarControllerHeader
442 636 self.m_ProcessingHeader
443 637 self.firstHeaderSize
444 638 self.dataType
445 639 self.fileSizeByHeader
446 640 self.ippSeconds
447 641
448 642 Return:
449 643 None
450 644 """
451 645 self.__rdBasicHeader()
452 646 self.__rdSystemHeader()
453 647 self.__rdRadarControllerHeader()
454 648 self.__rdProcessingHeader()
455 649 self.firstHeaderSize = self.m_BasicHeader.size
456 650
457 651 datatype = int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
458 652 if datatype == 0:
459 653 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
460 654
461 655 elif datatype == 1:
462 656 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
463 657
464 658 elif datatype == 2:
465 659 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
466 660
467 661 elif datatype == 3:
468 662 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
469 663
470 664 elif datatype == 4:
471 665 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
472 666
473 667 elif datatype == 5:
474 668 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
475 669
476 670 else:
477 671 raise ValueError, 'Data type was not defined'
478 672
479 673 self.dataType = datatype_str
480 674 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
481 675
482 676 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
483 677 self.dataOutObj.channelList = numpy.arange(self.m_SystemHeader.numChannels)
484 678 self.dataOutObj.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
485 679
486 680 self.getBlockDimension()
487 681
488 682
489 683 def __setNewBlock(self):
490 684 """
491 685 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
492 686
493 687 Affected:
494 688 self.m_BasicHeader
495 689 self.flagNoContinuousBlock
496 690 self.ns
497 691
498 692 Return:
499 693 0 : Si el file no tiene un Basic Header que pueda ser leido
500 694 1 : Si se pudo leer el Basic Header
501 695 """
502 696 if self.fp == None:
503 697 return 0
504 698
505 699 if self.flagIsNewFile:
506 700 return 1
507 701
508 702 self.lastUTTime = self.m_BasicHeader.utc
509 703
510 704 currentSize = self.fileSize - self.fp.tell()
511 705 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
512 706
513 707 #If there is enough data setting new data block
514 708 if ( currentSize >= neededSize ):
515 709 self.__rdBasicHeader()
516 710 return 1
517 711
518 712 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
519 713 if self.online and (self.nReadBlocks < self.m_ProcessingHeader.dataBlocksPerFile):
520 714
521 715 fpointer = self.fp.tell()
522 716
523 717 for nTries in range( self.nTries ):
524 718 #self.fp.close()
525 719
526 720 print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
527 721 time.sleep( self.delay )
528 722
529 723 #self.fp = open( self.filename, 'rb' )
530 724 #self.fp.seek( fpointer )
531 725
532 726 self.fileSize = os.path.getsize( self.filename )
533 727 currentSize = self.fileSize - fpointer
534 728
535 729 if ( currentSize >= neededSize ):
536 730 self.__rdBasicHeader()
537 731 return 1
538 732
539 733 #Setting new file
540 734 if not( self.setNextFile() ):
541 735 return 0
542 736
543 737 deltaTime = self.m_BasicHeader.utc - self.lastUTTime # check this
544 738
545 739 self.flagResetProcessing = 0
546 740
547 741 if deltaTime > self.maxTimeStep:
548 742 self.flagResetProcessing = 1
549 743
550 744 return 1
551 745
552 746 def readNextBlock(self):
553 747 """
554 748 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
555 749 mas bloques disponibles en el archivo actual salta al siguiente.
556 750
557 751 Affected:
558 752 self.lastUTTime
559 753
560 754 Return: None
561 755 """
562 756
563 757 if not(self.__setNewBlock()):
564 758 return 0
565 759
566 760 if not(self.readBlock()):
567 761 return 0
568 762
569 763 return 1
570 764
571 765 def __setNextFileOnline(self):
572 766 """
573 767 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
574 768 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
575 769 siguientes.
576 770
577 771 Affected:
578 772 self.flagIsNewFile
579 773 self.filename
580 774 self.fileSize
581 775 self.fp
582 776 self.set
583 777 self.flagNoMoreFiles
584 778
585 779 Return:
586 780 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
587 781 1 : si el file fue abierto con exito y esta listo a ser leido
588 782
589 783 Excepciones:
590 784 Si un determinado file no puede ser abierto
591 785 """
592 786 nFiles = 0
593 787 fileOk_flag = False
594 788 firstTime_flag = True
595 789
596 790 self.set += 1
597 791
598 792 #busca el 1er file disponible
599 793 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
600 794 if file:
601 795 if self.__verifyFile(file, False):
602 796 fileOk_flag = True
603 797
604 798 #si no encuentra un file entonces espera y vuelve a buscar
605 799 if not(fileOk_flag):
606 800 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
607 801
608 802 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
609 803 tries = self.nTries
610 804 else:
611 805 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
612 806
613 807 for nTries in range( tries ):
614 808 if firstTime_flag:
615 809 print "\tWaiting %0.2f sec for new \"%s\" file, try %03d ..." % ( self.delay, filename, nTries+1 )
616 810 time.sleep( self.delay )
617 811 else:
618 812 print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
619 813
620 814 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
621 815 if file:
622 816 if self.__verifyFile(file):
623 817 fileOk_flag = True
624 818 break
625 819
626 820 if fileOk_flag:
627 821 break
628 822
629 823 firstTime_flag = False
630 824
631 825 print "\tSkipping the file \"%s\" due to this file doesn't exist yet" % filename
632 826 self.set += 1
633 827
634 828 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
635 829 self.set = 0
636 830 self.doy += 1
637 831
638 832 if fileOk_flag:
639 833 self.fileSize = os.path.getsize( file )
640 834 self.filename = file
641 835 self.flagIsNewFile = 1
642 836 if self.fp != None: self.fp.close()
643 837 self.fp = open(file)
644 838 self.flagNoMoreFiles = 0
645 839 print 'Setting the file: %s' % file
646 840 else:
647 841 self.fileSize = 0
648 842 self.filename = None
649 843 self.flagIsNewFile = 0
650 844 self.fp = None
651 845 self.flagNoMoreFiles = 1
652 846 print 'No more Files'
653 847
654 848 return fileOk_flag
655 849
656 850
657 851 def __setNextFileOffline(self):
658 852 """
659 853 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
660 854
661 855 Affected:
662 856 self.flagIsNewFile
663 857 self.fileIndex
664 858 self.filename
665 859 self.fileSize
666 860 self.fp
667 861
668 862 Return:
669 863 0 : si un determinado file no puede ser abierto
670 864 1 : si el file fue abierto con exito
671 865
672 866 Excepciones:
673 867 Si un determinado file no puede ser abierto
674 868 """
675 869 idFile = self.fileIndex
676 870
677 871 while(True):
678 872
679 873 idFile += 1
680 874
681 875 if not(idFile < len(self.filenameList)):
682 876 self.flagNoMoreFiles = 1
683 877 print 'No more Files'
684 878 return 0
685 879
686 880 filename = self.filenameList[idFile]
687 881
688 882 if not(self.__verifyFile(filename)):
689 883 continue
690 884
691 885 fileSize = os.path.getsize(filename)
692 886 fp = open(filename,'rb')
693 887 break
694 888
695 889 self.flagIsNewFile = 1
696 890 self.fileIndex = idFile
697 891 self.filename = filename
698 892 self.fileSize = fileSize
699 893 self.fp = fp
700 894
701 895 print 'Setting the file: %s'%self.filename
702 896
703 897 return 1
704 898
705 899
706 900 def setNextFile(self):
707 901 """
708 902 Determina el siguiente file a leer y si hay uno disponible lee el First Header
709 903
710 904 Affected:
711 905 self.m_BasicHeader
712 906 self.m_SystemHeader
713 907 self.m_RadarControllerHeader
714 908 self.m_ProcessingHeader
715 909 self.firstHeaderSize
716 910
717 911 Return:
718 912 0 : Si no hay files disponibles
719 913 1 : Si hay mas files disponibles
720 914 """
721 915 if self.fp != None:
722 916 self.fp.close()
723 917
724 918 if self.online:
725 919 newFile = self.__setNextFileOnline()
726 920 else:
727 921 newFile = self.__setNextFileOffline()
728 922
729 923 if not(newFile):
730 924 return 0
731 925
732 926 self.__readFirstHeader()
733 927 self.nReadBlocks = 0
734 928 return 1
735 929
736 def __searchFilesOnLine(self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = None):
737 """
738 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
739 devuelve el archivo encontrado ademas de otros datos.
740
741 Input:
742 path : carpeta donde estan contenidos los files que contiene data
743 startDateTime : punto especifico en el tiempo del cual se requiere la data
744 ext : extension de los files
745
746 Return:
747 year : el anho
748 doy : el numero de dia del anho
749 set : el set del archivo
750 filename : el ultimo file de una determinada carpeta
751 directory : eL directorio donde esta el file encontrado
752 """
753 dirList = []
754 pathList = []
755 directory = None
756
757 for thisPath in os.listdir(path):
758 if os.path.isdir(os.path.join(path,thisPath)):
759 dirList.append(thisPath)
760
761 if not(dirList):
762 return None, None, None, None, None
763
764 dirList = sorted( dirList, key=str.lower )
765
766 if startDateTime:
767 thisDateTime = startDateTime
768 if endDateTime == None: endDateTime = 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 if not(pathList):
783 print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
784 return None, None, None, None, None
785
786 directory = pathList[0]
787
788 else:
789 directory = dirList[-1]
790 directory = os.path.join(path,directory)
791
792 filename = getlastFileFromPath(directory, ext)
793
794 if not(filename):
795 return None, None, None, None, None
796
797 if not(self.__verifyFile(os.path.join(directory, filename))):
798 return None, None, None, None, None
799
800 year = int( filename[1:5] )
801 doy = int( filename[5:8] )
802 set = int( filename[8:11] )
803
804 return directory, filename, year, doy, set
805
806
807 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
808 """
809 Realiza una busqueda de los archivos que coincidan con los parametros
810 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
811 correcta la estructura de directorios debe ser la siguiente:
812
813 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
814
815 [yyyy]: anio
816 [ddd] : dia del anio
817 [sss] : set del archivo
818
819 Inputs:
820 path : Directorio de datos donde se realizara la busqueda. Todos los
821 ficheros que concidan con el criterio de busqueda seran
822 almacenados en una lista y luego retornados.
823 startDateTime : Fecha inicial. Rechaza todos los archivos donde
824 file end time < startDateTime (obejto datetime.datetime)
825
826 endDateTime : Fecha final. Rechaza todos los archivos donde
827 file start time > endDateTime (obejto datetime.datetime)
828
829 set : Set del primer archivo a leer. Por defecto None
830
831 expLabel : Nombre del subdirectorio de datos. Por defecto ""
832
833 ext : Extension de los archivos a leer. Por defecto .r
834
835 Return:
836
837 (pathList, filenameList)
838
839 pathList : Lista de directorios donde se encontraron archivos dentro
840 de los parametros especificados
841 filenameList : Lista de archivos (ruta completa) que coincidieron con los
842 parametros especificados.
843
844 Variables afectadas:
845
846 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
847 como fuente para leer los bloque de datos, si se termina
848 de leer todos los bloques de datos de un determinado
849 archivo se pasa al siguiente archivo de la lista.
850
851 Excepciones:
852
853 """
854
855 print "Searching files ..."
856
857 dirList = []
858 for thisPath in os.listdir(path):
859 if os.path.isdir(os.path.join(path,thisPath)):
860 dirList.append(thisPath)
861
862 if not(dirList):
863 return None, None
864
865 pathList = []
866
867 thisDateTime = startDateTime
868
869 while(thisDateTime <= endDateTime):
870 year = thisDateTime.timetuple().tm_year
871 doy = thisDateTime.timetuple().tm_yday
872
873 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
874 if len(match) == 0:
875 thisDateTime += datetime.timedelta(1)
876 continue
877
878 pathList.append(os.path.join(path,match[0],expLabel))
879 thisDateTime += datetime.timedelta(1)
880
881 startUtSeconds = time.mktime(startDateTime.timetuple())
882 endUtSeconds = time.mktime(endDateTime.timetuple())
883
884 filenameList = []
885 for thisPath in pathList:
886 fileList = glob.glob1(thisPath, "*%s" %ext)
887 fileList.sort()
888 for file in fileList:
889 filename = os.path.join(thisPath,file)
890 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
891 filenameList.append(filename)
892
893 if not(filenameList):
894 return None, None
895
896 self.filenameList = filenameList
897
898 return pathList, filenameList
899
900 930 def __verifyFile(self, filename, msgFlag=True):
901 931 """
902 932 Verifica que el filename tenga data valida, para ello leo el FirstHeader del file
903 933
904 934 Return:
905 935 0 : file no valido para ser leido
906 936 1 : file valido para ser leido
907 937 """
908 938 msg = None
909 939
910 940 try:
911 941 fp = open( filename,'rb' ) #lectura binaria
912 942 currentPosition = fp.tell()
913 943 except:
914 944 if msgFlag:
915 945 print "The file %s can't be opened" % (filename)
916 946 return False
917 947
918 948 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
919 949
920 950 if neededSize == 0:
921 951
922 952 m_BasicHeader = BasicHeader()
923 953 m_SystemHeader = SystemHeader()
924 954 m_RadarControllerHeader = RadarControllerHeader()
925 955 m_ProcessingHeader = ProcessingHeader()
926 956
927 957 try:
928 958 if not( m_BasicHeader.read(fp) ): raise ValueError
929 959 if not( m_SystemHeader.read(fp) ): raise ValueError
930 960 if not( m_RadarControllerHeader.read(fp) ): raise ValueError
931 961 if not( m_ProcessingHeader.read(fp) ): raise ValueError
932 962 data_type = int(numpy.log2((m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
933 963
934 964 neededSize = m_ProcessingHeader.blockSize + m_BasicHeader.size
935 965
936 966 except:
937 967 if msgFlag:
938 968 print "\tThe file %s is empty or it hasn't enough data" % filename
939 969
940 970 fp.close()
941 971 return False
942 972
943 973 else:
944 974 msg = "\tSkipping the file %s due to it hasn't enough data" %filename
945 975
946 976 fp.close()
947 977 fileSize = os.path.getsize(filename)
948 978 currentSize = fileSize - currentPosition
949 979
950 980 if currentSize < neededSize:
951 981 if msgFlag and (msg != None):
952 982 print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
953 983 return False
954 984
955 985 return True
956 986
957 987 def updateDataHeader(self):
958 988
959 989 self.dataOutObj.m_BasicHeader = self.m_BasicHeader.copy()
960 990 self.dataOutObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
961 991 self.dataOutObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
962 992 self.dataOutObj.m_SystemHeader = self.m_SystemHeader.copy()
963 993
964 994 self.dataOutObj.dataType = self.dataType
965 995 self.dataOutObj.updateObjFromHeader()
966 996
967 997
968 998 class JRODataWriter(JRODataIO):
969 999
970 1000 """
971 1001 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
972 1002 de los datos siempre se realiza por bloques.
973 1003 """
974 1004
975 1005 nWriteBlocks = 0
976 1006
977 1007 setFile = None
978 1008
979 1009
980 1010 def __init__(self, dataOutObj=None):
981 1011 raise ValueError, "Not implemented"
982 1012
983 1013
984 1014 def hasAllDataInBuffer(self):
985 1015 raise ValueError, "Not implemented"
986 1016
987 1017
988 1018 def setBlockDimension(self):
989 1019 raise ValueError, "Not implemented"
990 1020
991 1021
992 1022 def writeBlock(self):
993 1023 raise ValueError, "No implemented"
994 1024
995 1025
996 1026 def putData(self):
997 1027 raise ValueError, "No implemented"
998 1028
999 1029
1000 1030 def __writeFirstHeader(self):
1001 1031 """
1002 1032 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1003 1033
1004 1034 Affected:
1005 1035 __dataType
1006 1036
1007 1037 Return:
1008 1038 None
1009 1039 """
1010 1040 self.__writeBasicHeader()
1011 1041 self.__wrSystemHeader()
1012 1042 self.__wrRadarControllerHeader()
1013 1043 self.__wrProcessingHeader()
1014 1044 self.dataType = self.dataOutObj.dataType
1015 1045
1016 1046
1017 1047 def __writeBasicHeader(self, fp=None):
1018 1048 """
1019 1049 Escribe solo el Basic header en el file creado
1020 1050
1021 1051 Return:
1022 1052 None
1023 1053 """
1024 1054 if fp == None:
1025 1055 fp = self.fp
1026 1056
1027 1057 self.dataOutObj.m_BasicHeader.write(fp)
1028 1058
1029 1059
1030 1060 def __wrSystemHeader(self, fp=None):
1031 1061 """
1032 1062 Escribe solo el System header en el file creado
1033 1063
1034 1064 Return:
1035 1065 None
1036 1066 """
1037 1067 if fp == None:
1038 1068 fp = self.fp
1039 1069
1040 1070 self.dataOutObj.m_SystemHeader.write(fp)
1041 1071
1042 1072
1043 1073 def __wrRadarControllerHeader(self, fp=None):
1044 1074 """
1045 1075 Escribe solo el RadarController header en el file creado
1046 1076
1047 1077 Return:
1048 1078 None
1049 1079 """
1050 1080 if fp == None:
1051 1081 fp = self.fp
1052 1082
1053 1083 self.dataOutObj.m_RadarControllerHeader.write(fp)
1054 1084
1055 1085
1056 1086 def __wrProcessingHeader(self, fp=None):
1057 1087 """
1058 1088 Escribe solo el Processing header en el file creado
1059 1089
1060 1090 Return:
1061 1091 None
1062 1092 """
1063 1093 if fp == None:
1064 1094 fp = self.fp
1065 1095
1066 1096 self.dataOutObj.m_ProcessingHeader.write(fp)
1067 1097
1068 1098
1069 1099 def setNextFile(self):
1070 1100 """
1071 1101 Determina el siguiente file que sera escrito
1072 1102
1073 1103 Affected:
1074 1104 self.filename
1075 1105 self.subfolder
1076 1106 self.fp
1077 1107 self.setFile
1078 1108 self.flagIsNewFile
1079 1109
1080 1110 Return:
1081 1111 0 : Si el archivo no puede ser escrito
1082 1112 1 : Si el archivo esta listo para ser escrito
1083 1113 """
1084 1114 ext = self.ext
1085 1115 path = self.path
1086 1116
1087 1117 if self.fp != None:
1088 1118 self.fp.close()
1089 1119
1090 1120 timeTuple = time.localtime( self.dataOutObj.m_BasicHeader.utc )
1091 1121 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1092 1122
1093 1123 doypath = os.path.join( path, subfolder )
1094 1124 if not( os.path.exists(doypath) ):
1095 1125 os.mkdir(doypath)
1096 1126 self.setFile = -1 #inicializo mi contador de seteo
1097 1127 else:
1098 1128 filesList = os.listdir( doypath )
1099 1129 if len( filesList ) > 0:
1100 1130 filesList = sorted( filesList, key=str.lower )
1101 1131 filen = filesList[-1]
1102 1132 # el filename debera tener el siguiente formato
1103 1133 # 0 1234 567 89A BCDE (hex)
1104 1134 # x YYYY DDD SSS .ext
1105 1135 if isNumber( filen[8:11] ):
1106 1136 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1107 1137 else:
1108 1138 self.setFile = -1
1109 1139 else:
1110 1140 self.setFile = -1 #inicializo mi contador de seteo
1111 1141
1112 1142 setFile = self.setFile
1113 1143 setFile += 1
1114 1144
1115 1145 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
1116 1146 timeTuple.tm_year,
1117 1147 timeTuple.tm_yday,
1118 1148 setFile,
1119 1149 ext )
1120 1150
1121 1151 filename = os.path.join( path, subfolder, file )
1122 1152
1123 1153 fp = open( filename,'wb' )
1124 1154
1125 1155 self.nWriteBlocks = 0
1126 1156
1127 1157 #guardando atributos
1128 1158 self.filename = filename
1129 1159 self.subfolder = subfolder
1130 1160 self.fp = fp
1131 1161 self.setFile = setFile
1132 1162 self.flagIsNewFile = 1
1133 1163
1134 1164 print 'Writing the file: %s'%self.filename
1135 1165
1136 1166 self.__writeFirstHeader()
1137 1167
1138 1168 return 1
1139 1169
1140 1170
1141 1171 def __setNewBlock(self):
1142 1172 """
1143 1173 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1144 1174
1145 1175 Return:
1146 1176 0 : si no pudo escribir nada
1147 1177 1 : Si escribio el Basic el First Header
1148 1178 """
1149 1179 if self.fp == None:
1150 1180 self.setNextFile()
1151 1181
1152 1182 if self.flagIsNewFile:
1153 1183 return 1
1154 1184
1155 1185 if self.nWriteBlocks < self.m_ProcessingHeader.dataBlocksPerFile:
1156 1186 self.__writeBasicHeader()
1157 1187 return 1
1158 1188
1159 1189 if not( self.setNextFile() ):
1160 1190 return 0
1161 1191
1162 1192 return 1
1163 1193
1164 1194
1165 1195 def writeNextBlock(self):
1166 1196 """
1167 1197 Selecciona el bloque siguiente de datos y los escribe en un file
1168 1198
1169 1199 Return:
1170 1200 0 : Si no hizo pudo escribir el bloque de datos
1171 1201 1 : Si no pudo escribir el bloque de datos
1172 1202 """
1173 1203 if not( self.__setNewBlock() ):
1174 1204 return 0
1175 1205
1176 1206 self.writeBlock()
1177 1207
1178 1208 return 1
1179 1209
1180 1210
1181 1211 def getDataHeader(self):
1182 1212 """
1183 1213 Obtiene una copia del First Header
1184 1214
1185 1215 Affected:
1186 1216 self.m_BasicHeader
1187 1217 self.m_SystemHeader
1188 1218 self.m_RadarControllerHeader
1189 1219 self.m_ProcessingHeader
1190 1220 self.dataType
1191 1221
1192 1222 Return:
1193 1223 None
1194 1224 """
1195 1225 self.dataOutObj.updateHeaderFromObj()
1196 1226
1197 1227 self.m_BasicHeader = self.dataOutObj.m_BasicHeader.copy()
1198 1228 self.m_SystemHeader = self.dataOutObj.m_SystemHeader.copy()
1199 1229 self.m_RadarControllerHeader = self.dataOutObj.m_RadarControllerHeader.copy()
1200 1230 self.m_ProcessingHeader = self.dataOutObj.m_ProcessingHeader.copy()
1201 1231
1202 1232 self.dataType = self.dataOutObj.dataType
1203 1233
1204 1234
1205 1235 def setup(self, path, set=0, ext=None):
1206 1236 """
1207 1237 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1208 1238
1209 1239 Inputs:
1210 1240 path : el path destino en el cual se escribiran los files a crear
1211 1241 format : formato en el cual sera salvado un file
1212 1242 set : el setebo del file
1213 1243
1214 1244 Return:
1215 1245 0 : Si no realizo un buen seteo
1216 1246 1 : Si realizo un buen seteo
1217 1247 """
1218 1248
1219 1249 if ext == None:
1220 1250 ext = self.ext
1221 1251
1222 1252 ext = ext.lower()
1223 1253
1224 1254 self.path = path
1225 1255 self.setFile = set - 1
1226 1256 self.ext = ext
1227 1257 #self.format = format
1228 1258 self.getDataHeader()
1229 1259
1230 1260 self.setBlockDimension()
1231 1261
1232 1262 if not( self.setNextFile() ):
1233 1263 print "There isn't a next file"
1234 1264 return 0
1235 1265
1236 1266 return 1
General Comments 0
You need to be logged in to leave comments. Login now