##// END OF EJS Templates
schain
RSS
schainpy2:...
Miguel Valdez -
r166:f7539cb45685
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,763 +1,1047
1 1 '''
2 2
3 3 $Author$
4 4 $Id$
5 5 '''
6 6
7 7 import os, sys
8 8 import glob
9 9 import time
10 10 import numpy
11 11 import fnmatch
12 12 import time, datetime
13 13
14 14 path = os.path.split(os.getcwd())[0]
15 15 sys.path.append(path)
16 16
17 17 from JROHeaderIO import *
18 18 from Data.JROData import JROData
19 19
20 20 def isNumber(str):
21 21 """
22 22 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
23 23
24 24 Excepciones:
25 25 Si un determinado string no puede ser convertido a numero
26 26 Input:
27 27 str, string al cual se le analiza para determinar si convertible a un numero o no
28 28
29 29 Return:
30 30 True : si el string es uno numerico
31 31 False : no es un string numerico
32 32 """
33 33 try:
34 34 float( str )
35 35 return True
36 36 except:
37 37 return False
38 38
39 39 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
40 40 """
41 41 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
42 42
43 43 Inputs:
44 44 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
45 45
46 46 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
47 47 segundos contados desde 01/01/1970.
48 48 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
49 49 segundos contados desde 01/01/1970.
50 50
51 51 Return:
52 52 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
53 53 fecha especificado, de lo contrario retorna False.
54 54
55 55 Excepciones:
56 56 Si el archivo no existe o no puede ser abierto
57 57 Si la cabecera no puede ser leida.
58 58
59 59 """
60 60 basicHeaderObj = BasicHeader()
61 61
62 62 try:
63 63 fp = open(filename,'rb')
64 64 except:
65 65 raise IOError, "The file %s can't be opened" %(filename)
66 66
67 67 sts = basicHeaderObj.read(fp)
68 68 fp.close()
69 69
70 70 if not(sts):
71 71 print "Skipping the file %s because it has not a valid header" %(filename)
72 72 return 0
73 73
74 74 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
75 75 return 0
76 76
77 77 return 1
78 78
79 def getlastFileFromPath(path, ext):
80 """
81 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
82 al final de la depuracion devuelve el ultimo file de la lista que quedo.
83
84 Input:
85 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
86 ext : extension de los files contenidos en una carpeta
87
88 Return:
89 El ultimo file de una determinada carpeta, no se considera el path.
90 """
91 validFilelist = []
92 fileList = os.listdir(path)
93
94 # 0 1234 567 89A BCDE
95 # H YYYY DDD SSS .ext
96
97 for file in fileList:
98 try:
99 year = int(file[1:5])
100 doy = int(file[5:8])
101
102 if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue
103 except:
104 continue
105
106 validFilelist.append(file)
79 107
108 if validFilelist:
109 validFilelist = sorted( validFilelist, key=str.lower )
110 return validFilelist[-1]
80 111
112 return None
113
114 def checkForRealPath(path, year, doy, set, ext):
115 """
116 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
117 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
118 el path exacto de un determinado file.
119
120 Example :
121 nombre correcto del file es .../.../D2009307/P2009307367.ext
122
123 Entonces la funcion prueba con las siguientes combinaciones
124 .../.../x2009307/y2009307367.ext
125 .../.../x2009307/Y2009307367.ext
126 .../.../X2009307/y2009307367.ext
127 .../.../X2009307/Y2009307367.ext
128 siendo para este caso, la ultima combinacion de letras, identica al file buscado
129
130 Return:
131 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
132 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
133 para el filename
134 """
135 filepath = None
136 find_flag = False
137 filename = None
138
139 if ext.lower() == ".r": #voltage
140 header1 = "dD"
141 header2 = "dD"
142 elif ext.lower() == ".pdata": #spectra
143 header1 = "dD"
144 header2 = "pP"
145 else:
146 return None, filename
147
148 for dir in header1: #barrido por las dos combinaciones posibles de "D"
149 for fil in header2: #barrido por las dos combinaciones posibles de "D"
150 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
151 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
152 filepath = os.path.join( path, doypath, filename ) #formo el path completo
153 if os.path.exists( filepath ): #verifico que exista
154 find_flag = True
155 break
156 if find_flag:
157 break
158
159 if not(find_flag):
160 return None, filename
161
162 return filepath, filename
81 163
82 164 class JRODataIO:
83 165
84 166 c = 3E8
85 167
86 168 basicHeaderObj = BasicHeader()
87 169
88 170 systemHeaderObj = SystemHeader()
89 171
90 172 radarControllerHeaderObj = RadarControllerHeader()
91 173
92 174 processingHeaderObj = ProcessingHeader()
93 175
94 176 online = 0
95 177
96 178 dtype = None
97 179
98 180 pathList = []
99 181
100 182 filenameList = []
101 183
102 184 filename = None
103 185
104 186 ext = None
105 187
106 188 flagNoMoreFiles = 0
107 189
108 190 flagIsNewFile = 1
109 191
110 192 flagTimeBlock = 0
111 193
112 194 flagIsNewBlock = 0
113 195
114 196 fp = None
115 197
116 198 firstHeaderSize = 0
117 199
118 200 basicHeaderSize = 24
119 201
120 202 versionFile = 1103
121 203
122 204 fileSize = None
123 205
124 206 ippSeconds = None
125 207
126 208 fileSizeByHeader = None
127 209
128 210 fileIndex = None
129 211
130 212 profileIndex = None
131 213
132 214 blockIndex = None
133 215
134 216 nTotalBlocks = None
135 217
136 218 maxTimeStep = 30
137 219
138 220 lastUTTime = None
139 221
140 222 datablock = None
141 223
142 224 dataOutObj = None
143 225
144 226 blocksize = None
145 227
146 228 def __init__(self):
147 229 pass
148 230
149 231 class JRODataReader(JRODataIO):
150 232
151 233 nReadBlocks = 0
152 234
235 delay = 60 #number of seconds waiting a new file
236
237 nTries = 3 #quantity tries
238
239 nFiles = 3 #number of files for searching
240
241
153 242 def __init__(self):
154 243
155 244 pass
156 245
157 246 def createObjByDefault(self):
158 247 """
159 248
160 249 """
161 250 raise ValueError, "This method has not been implemented"
162 251
163 252 def getBlockDimension(self):
164 253
165 254 raise ValueError, "No implemented"
166 255
167 256 def __searchFilesOffLine(self,
168 257 path,
169 258 startDate,
170 259 endDate,
171 260 startTime=datetime.time(0,0,0),
172 261 endTime=datetime.time(23,59,59),
173 262 set=None,
174 263 expLabel="",
175 264 ext=".r"):
176 265 dirList = []
177 266 for thisPath in os.listdir(path):
178 267 if os.path.isdir(os.path.join(path,thisPath)):
179 268 dirList.append(thisPath)
180 269
181 270 if not(dirList):
182 271 return None, None
183 272
184 273 pathList = []
185 274 dateList = []
186 275
187 276 thisDate = startDate
188 277
189 278 while(thisDate <= endDate):
190 279 year = thisDate.timetuple().tm_year
191 280 doy = thisDate.timetuple().tm_yday
192 281
193 282 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
194 283 if len(match) == 0:
195 284 thisDate += datetime.timedelta(1)
196 285 continue
197 286
198 287 pathList.append(os.path.join(path,match[0],expLabel))
199 288 dateList.append(thisDate)
200 289 thisDate += datetime.timedelta(1)
201 290
202 291 filenameList = []
203 292 for index in range(len(pathList)):
204 293
205 294 thisPath = pathList[index]
206 295 fileList = glob.glob1(thisPath, "*%s" %ext)
207 296 fileList.sort()
208 297
209 298 #Busqueda de datos en el rango de horas indicados
210 299 thisDate = dateList[index]
211 300 startDT = datetime.datetime.combine(thisDate, startTime)
212 301 endDT = datetime.datetime.combine(thisDate, endTime)
213 302
214 303 startUtSeconds = time.mktime(startDT.timetuple())
215 304 endUtSeconds = time.mktime(endDT.timetuple())
216 305
217 306 for file in fileList:
218 307
219 308 filename = os.path.join(thisPath,file)
220 309
221 310 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
222 311 filenameList.append(filename)
223 312
224 313 if not(filenameList):
225 314 return None, None
226 315
227 316 self.filenameList = filenameList
228 317
229 318 return pathList, filenameList
319
320 def __searchFilesOnLine(self, path, startDate=None, endDate=None, startTime=None, endTime=None, expLabel = "", ext = None):
321
322 """
323 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
324 devuelve el archivo encontrado ademas de otros datos.
325
326 Input:
327 path : carpeta donde estan contenidos los files que contiene data
328
329 startDate : Fecha inicial. Rechaza todos los directorios donde
330 file end time < startDate (obejto datetime.date)
331
332 endDate : Fecha final. Rechaza todos los directorios donde
333 file start time > endDate (obejto datetime.date)
334
335 startTime : Tiempo inicial. Rechaza todos los archivos donde
336 file end time < startTime (obejto datetime.time)
337
338 endTime : Tiempo final. Rechaza todos los archivos donde
339 file start time > endTime (obejto datetime.time)
340
341 expLabel : Nombre del subexperimento (subfolder)
342
343 ext : extension de los files
230 344
345 Return:
346 directory : eL directorio donde esta el file encontrado
347 filename : el ultimo file de una determinada carpeta
348 year : el anho
349 doy : el numero de dia del anho
350 set : el set del archivo
351
352
353 """
354 dirList = []
355 pathList = []
356 directory = None
357
358 #Filtra solo los directorios
359 for thisPath in os.listdir(path):
360 if os.path.isdir(os.path.join(path, thisPath)):
361 dirList.append(thisPath)
362
363 if not(dirList):
364 return None, None, None, None, None
365
366 dirList = sorted( dirList, key=str.lower )
367
368 if startDate:
369 startDateTime = datetime.datetime.combine(startDate, startTime)
370 thisDateTime = startDateTime
371 if endDate == None: endDateTime = startDateTime
372 else: endDateTime = datetime.datetime.combine(endDate, endTime)
373
374 while(thisDateTime <= endDateTime):
375 year = thisDateTime.timetuple().tm_year
376 doy = thisDateTime.timetuple().tm_yday
377
378 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
379 if len(match) == 0:
380 thisDateTime += datetime.timedelta(1)
381 continue
382
383 pathList.append(os.path.join(path,match[0], expLabel))
384 thisDateTime += datetime.timedelta(1)
385
386 if not(pathList):
387 print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
388 return None, None, None, None, None
389
390 directory = pathList[0]
391
392 else:
393 directory = dirList[-1]
394 directory = os.path.join(path,directory)
395
396 filename = getlastFileFromPath(directory, ext)
397
398 if not(filename):
399 return None, None, None, None, None
400
401 if not(self.__verifyFile(os.path.join(directory, filename))):
402 return None, None, None, None, None
403
404 year = int( filename[1:5] )
405 doy = int( filename[5:8] )
406 set = int( filename[8:11] )
407
408 return directory, filename, year, doy, set
409
231 410 def setup(self,dataOutObj=None,
232 411 path=None,
233 412 startDate=None,
234 413 endDate=None,
235 414 startTime=datetime.time(0,0,0),
236 415 endTime=datetime.time(23,59,59),
237 416 set=0,
238 417 expLabel = "",
239 418 ext = None,
240 online = 0):
419 online = False,
420 delay = 60):
241 421
242 422 if path == None:
243 423 raise ValueError, "The path is not valid"
244 424
245 425 if ext == None:
246 426 ext = self.ext
247 427
248 428 if dataOutObj == None:
249 429 dataOutObj = self.createObjByDefault()
250 430
251 431 self.dataOutObj = dataOutObj
252 432
253 433 if online:
254 pass
434 print "Searching files in online mode..."
435 doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext)
436
437 if not(doypath):
438 for nTries in range( self.nTries ):
439 print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
440 time.sleep( self.delay )
441 doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=exp)
442 if doypath:
443 break
444
445 if not(doypath):
446 print "There 'isn't valied files in %s" % path
447 return None
448
449 self.year = year
450 self.doy = doy
451 self.set = set - 1
452 self.path = path
255 453
256 454 else:
257 455 print "Searching files in offline mode ..."
258 456 pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
259 457
260 458 if not(pathList):
261 459 print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
262 460 datetime.datetime.combine(startDate,startTime).ctime(),
263 461 datetime.datetime.combine(endDate,endTime).ctime())
264 462
265 463 sys.exit(-1)
266 464
267 465
268 466 self.fileIndex = -1
269 467 self.pathList = pathList
270 468 self.filenameList = filenameList
271 469
272 470 self.online = online
471 self.delay = delay
273 472 ext = ext.lower()
274 473 self.ext = ext
275 474
276 475 if not(self.setNextFile()):
277 476 if (startDate!=None) and (endDate!=None):
278 477 print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
279 478 elif startDate != None:
280 479 print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
281 480 else:
282 481 print "No files"
283 482
284 483 sys.exit(-1)
285 484
286 485 # self.updateDataHeader()
287 486
288 487 return self.dataOutObj
289 488
290 489 def __setNextFileOffline(self):
490
291 491 idFile = self.fileIndex
292 492
293 493 while (True):
294 494 idFile += 1
295 495 if not(idFile < len(self.filenameList)):
296 496 self.flagNoMoreFiles = 1
297 497 print "No more Files"
298 498 return 0
299 499
300 500 filename = self.filenameList[idFile]
301 501
302 502 if not(self.__verifyFile(filename)):
303 503 continue
304 504
305 505 fileSize = os.path.getsize(filename)
306 506 fp = open(filename,'rb')
307 507 break
308 508
309 509 self.flagIsNewFile = 1
310 510 self.fileIndex = idFile
311 511 self.filename = filename
312 512 self.fileSize = fileSize
313 513 self.fp = fp
314 514
315 515 print "Setting the file: %s"%self.filename
316 516
317 517 return 1
318 518
519 def __setNextFileOnline(self):
520 """
521 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
522 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
523 siguientes.
524
525 Affected:
526 self.flagIsNewFile
527 self.filename
528 self.fileSize
529 self.fp
530 self.set
531 self.flagNoMoreFiles
532
533 Return:
534 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
535 1 : si el file fue abierto con exito y esta listo a ser leido
536
537 Excepciones:
538 Si un determinado file no puede ser abierto
539 """
540 nFiles = 0
541 fileOk_flag = False
542 firstTime_flag = True
543
544 self.set += 1
545
546 #busca el 1er file disponible
547 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
548 if file:
549 if self.__verifyFile(file, False):
550 fileOk_flag = True
551
552 #si no encuentra un file entonces espera y vuelve a buscar
553 if not(fileOk_flag):
554 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
555
556 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
557 tries = self.nTries
558 else:
559 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
560
561 for nTries in range( tries ):
562 if firstTime_flag:
563 print "\tWaiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
564 time.sleep( self.delay )
565 else:
566 print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
567
568 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
569 if file:
570 if self.__verifyFile(file):
571 fileOk_flag = True
572 break
573
574 if fileOk_flag:
575 break
576
577 firstTime_flag = False
578
579 print "\tSkipping the file \"%s\" due to this file doesn't exist" % filename
580 self.set += 1
581
582 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
583 self.set = 0
584 self.doy += 1
585
586 if fileOk_flag:
587 self.fileSize = os.path.getsize( file )
588 self.filename = file
589 self.flagIsNewFile = 1
590 if self.fp != None: self.fp.close()
591 self.fp = open(file)
592 self.flagNoMoreFiles = 0
593 print 'Setting the file: %s' % file
594 else:
595 self.fileSize = 0
596 self.filename = None
597 self.flagIsNewFile = 0
598 self.fp = None
599 self.flagNoMoreFiles = 1
600 print 'No more Files'
601
602 return fileOk_flag
319 603
320 604
321 605 def setNextFile(self):
322 606 if self.fp != None:
323 607 self.fp.close()
324 608
325 609 if self.online:
326 610 newFile = self.__setNextFileOnline()
327 611 else:
328 612 newFile = self.__setNextFileOffline()
329 613
330 614 if not(newFile):
331 615 return 0
332 616
333 617 self.__readFirstHeader()
334 618 self.nReadBlocks = 0
335 619 return 1
336 620
337 621 def __setNewBlock(self):
338 622 if self.fp == None:
339 623 return 0
340 624
341 625 if self.flagIsNewFile:
342 626 return 1
343 627
344 628 self.lastUTTime = self.basicHeaderObj.utc
345 629 currentSize = self.fileSize - self.fp.tell()
346 630 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
347 631
348 632 if (currentSize >= neededSize):
349 633 self.__rdBasicHeader()
350 634 return 1
351 635
352 636 if not(self.setNextFile()):
353 637 return 0
354 638
355 639 deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
356 640
357 641 self.flagTimeBlock = 0
358 642
359 643 if deltaTime > self.maxTimeStep:
360 644 self.flagTimeBlock = 1
361 645
362 646 return 1
363 647
364 648
365 649 def readNextBlock(self):
366 650 if not(self.__setNewBlock()):
367 651 return 0
368 652
369 653 if not(self.readBlock()):
370 654 return 0
371 655
372 656 return 1
373 657
374 658 def __rdProcessingHeader(self, fp=None):
375 659 if fp == None:
376 660 fp = self.fp
377 661
378 662 self.processingHeaderObj.read(fp)
379 663
380 664 def __rdRadarControllerHeader(self, fp=None):
381 665 if fp == None:
382 666 fp = self.fp
383 667
384 668 self.radarControllerHeaderObj.read(fp)
385 669
386 670 def __rdSystemHeader(self, fp=None):
387 671 if fp == None:
388 672 fp = self.fp
389 673
390 674 self.systemHeaderObj.read(fp)
391 675
392 676 def __rdBasicHeader(self, fp=None):
393 677 if fp == None:
394 678 fp = self.fp
395 679
396 680 self.basicHeaderObj.read(fp)
397 681
398 682
399 683 def __readFirstHeader(self):
400 684 self.__rdBasicHeader()
401 685 self.__rdSystemHeader()
402 686 self.__rdRadarControllerHeader()
403 687 self.__rdProcessingHeader()
404 688
405 689 self.firstHeaderSize = self.basicHeaderObj.size
406 690
407 691 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
408 692 if datatype == 0:
409 693 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
410 694 elif datatype == 1:
411 695 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
412 696 elif datatype == 2:
413 697 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
414 698 elif datatype == 3:
415 699 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
416 700 elif datatype == 4:
417 701 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
418 702 elif datatype == 5:
419 703 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
420 704 else:
421 705 raise ValueError, 'Data type was not defined'
422 706
423 707 self.dtype = datatype_str
424 708 self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
425 709 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
426 710 # self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
427 711 # self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
428 712 self.getBlockDimension()
429 713
430 714
431 715 def __verifyFile(self, filename, msgFlag=True):
432 716 msg = None
433 717 try:
434 718 fp = open(filename, 'rb')
435 719 currentPosition = fp.tell()
436 720 except:
437 721 if msgFlag:
438 722 print "The file %s can't be opened" % (filename)
439 723 return False
440 724
441 725 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
442 726
443 727 if neededSize == 0:
444 728 basicHeaderObj = BasicHeader()
445 729 systemHeaderObj = SystemHeader()
446 730 radarControllerHeaderObj = RadarControllerHeader()
447 731 processingHeaderObj = ProcessingHeader()
448 732
449 733 try:
450 734 if not( basicHeaderObj.read(fp) ): raise ValueError
451 735 if not( systemHeaderObj.read(fp) ): raise ValueError
452 736 if not( radarControllerHeaderObj.read(fp) ): raise ValueError
453 737 if not( processingHeaderObj.read(fp) ): raise ValueError
454 738 data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
455 739
456 740 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
457 741
458 742 except:
459 743 if msgFlag:
460 744 print "\tThe file %s is empty or it hasn't enough data" % filename
461 745
462 746 fp.close()
463 747 return False
464 748 else:
465 749 msg = "\tSkipping the file %s due to it hasn't enough data" %filename
466 750
467 751 fp.close()
468 752 fileSize = os.path.getsize(filename)
469 753 currentSize = fileSize - currentPosition
470 754 if currentSize < neededSize:
471 755 if msgFlag and (msg != None):
472 756 print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
473 757 return False
474 758
475 759 return True
476 760
477 761 def getData():
478 762 pass
479 763
480 764 def hasNotDataInBuffer():
481 765 pass
482 766
483 767 def readBlock():
484 768 pass
485 769
486 770 class JRODataWriter(JRODataIO):
487 771
488 772 """
489 773 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
490 774 de los datos siempre se realiza por bloques.
491 775 """
492 776
493 777 blockIndex = 0
494 778
495 779 path = None
496 780
497 781 setFile = None
498 782
499 783 profilesPerBlock = None
500 784
501 785 blocksPerFile = None
502 786
503 787 nWriteBlocks = 0
504 788
505 789 def __init__(self, dataOutObj=None):
506 790 raise ValueError, "Not implemented"
507 791
508 792
509 793 def hasAllDataInBuffer(self):
510 794 raise ValueError, "Not implemented"
511 795
512 796
513 797 def setBlockDimension(self):
514 798 raise ValueError, "Not implemented"
515 799
516 800
517 801 def writeBlock(self):
518 802 raise ValueError, "No implemented"
519 803
520 804
521 805 def putData(self):
522 806 raise ValueError, "No implemented"
523 807
524 808
525 809 def __writeFirstHeader(self):
526 810 """
527 811 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
528 812
529 813 Affected:
530 814 __dataType
531 815
532 816 Return:
533 817 None
534 818 """
535 819
536 820 # CALCULAR PARAMETROS
537 821
538 822 sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
539 823 self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
540 824
541 825 self.__writeBasicHeader()
542 826 self.__wrSystemHeader()
543 827 self.__wrRadarControllerHeader()
544 828 self.__wrProcessingHeader()
545 829 self.dtype = self.dataOutObj.dtype
546 830
547 831
548 832 def __writeBasicHeader(self, fp=None):
549 833 """
550 834 Escribe solo el Basic header en el file creado
551 835
552 836 Return:
553 837 None
554 838 """
555 839 if fp == None:
556 840 fp = self.fp
557 841
558 842 self.basicHeaderObj.write(fp)
559 843
560 844
561 845 def __wrSystemHeader(self, fp=None):
562 846 """
563 847 Escribe solo el System header en el file creado
564 848
565 849 Return:
566 850 None
567 851 """
568 852 if fp == None:
569 853 fp = self.fp
570 854
571 855 self.systemHeaderObj.write(fp)
572 856
573 857
574 858 def __wrRadarControllerHeader(self, fp=None):
575 859 """
576 860 Escribe solo el RadarController header en el file creado
577 861
578 862 Return:
579 863 None
580 864 """
581 865 if fp == None:
582 866 fp = self.fp
583 867
584 868 self.radarControllerHeaderObj.write(fp)
585 869
586 870
587 871 def __wrProcessingHeader(self, fp=None):
588 872 """
589 873 Escribe solo el Processing header en el file creado
590 874
591 875 Return:
592 876 None
593 877 """
594 878 if fp == None:
595 879 fp = self.fp
596 880
597 881 self.processingHeaderObj.write(fp)
598 882
599 883
600 884 def setNextFile(self):
601 885 """
602 886 Determina el siguiente file que sera escrito
603 887
604 888 Affected:
605 889 self.filename
606 890 self.subfolder
607 891 self.fp
608 892 self.setFile
609 893 self.flagIsNewFile
610 894
611 895 Return:
612 896 0 : Si el archivo no puede ser escrito
613 897 1 : Si el archivo esta listo para ser escrito
614 898 """
615 899 ext = self.ext
616 900 path = self.path
617 901
618 902 if self.fp != None:
619 903 self.fp.close()
620 904
621 905 timeTuple = time.localtime( self.dataOutObj.dataUtcTime)
622 906 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
623 907
624 908 doypath = os.path.join( path, subfolder )
625 909 if not( os.path.exists(doypath) ):
626 910 os.mkdir(doypath)
627 911 self.setFile = -1 #inicializo mi contador de seteo
628 912 else:
629 913 filesList = os.listdir( doypath )
630 914 if len( filesList ) > 0:
631 915 filesList = sorted( filesList, key=str.lower )
632 916 filen = filesList[-1]
633 917 # el filename debera tener el siguiente formato
634 918 # 0 1234 567 89A BCDE (hex)
635 919 # x YYYY DDD SSS .ext
636 920 if isNumber( filen[8:11] ):
637 921 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
638 922 else:
639 923 self.setFile = -1
640 924 else:
641 925 self.setFile = -1 #inicializo mi contador de seteo
642 926
643 927 setFile = self.setFile
644 928 setFile += 1
645 929
646 930 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
647 931 timeTuple.tm_year,
648 932 timeTuple.tm_yday,
649 933 setFile,
650 934 ext )
651 935
652 936 filename = os.path.join( path, subfolder, file )
653 937
654 938 fp = open( filename,'wb' )
655 939
656 940 self.blockIndex = 0
657 941
658 942 #guardando atributos
659 943 self.filename = filename
660 944 self.subfolder = subfolder
661 945 self.fp = fp
662 946 self.setFile = setFile
663 947 self.flagIsNewFile = 1
664 948
665 949 self.getDataHeader()
666 950
667 951 print 'Writing the file: %s'%self.filename
668 952
669 953 self.__writeFirstHeader()
670 954
671 955 return 1
672 956
673 957
674 958 def __setNewBlock(self):
675 959 """
676 960 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
677 961
678 962 Return:
679 963 0 : si no pudo escribir nada
680 964 1 : Si escribio el Basic el First Header
681 965 """
682 966 if self.fp == None:
683 967 self.setNextFile()
684 968
685 969 if self.flagIsNewFile:
686 970 return 1
687 971
688 972 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
689 973 self.__writeBasicHeader()
690 974 return 1
691 975
692 976 if not( self.setNextFile() ):
693 977 return 0
694 978
695 979 return 1
696 980
697 981
698 982 def writeNextBlock(self):
699 983 """
700 984 Selecciona el bloque siguiente de datos y los escribe en un file
701 985
702 986 Return:
703 987 0 : Si no hizo pudo escribir el bloque de datos
704 988 1 : Si no pudo escribir el bloque de datos
705 989 """
706 990 if not( self.__setNewBlock() ):
707 991 return 0
708 992
709 993 self.writeBlock()
710 994
711 995 return 1
712 996
713 997
714 998 def getDataHeader(self):
715 999 """Obtiene una copia del First Header Affected: self.basicHeaderObj self.
716 1000 systemHeaderObj self.radarControllerHeaderObj self.processingHeaderObj self.
717 1001 dtype Return: None
718 1002 """
719 1003
720 1004 raise ValueError, "No implemented"
721 1005
722 1006 def setup(self, path, blocksPerFile, profilesPerBlock=None, set=0, ext=None):
723 1007 """
724 1008 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
725 1009
726 1010 Inputs:
727 1011 path : el path destino en el cual se escribiran los files a crear
728 1012 format : formato en el cual sera salvado un file
729 1013 set : el setebo del file
730 1014
731 1015 Return:
732 1016 0 : Si no realizo un buen seteo
733 1017 1 : Si realizo un buen seteo
734 1018 """
735 1019
736 1020 if ext == None:
737 1021 ext = self.ext
738 1022
739 1023 ext = ext.lower()
740 1024
741 1025 self.ext = ext
742 1026
743 1027 self.path = path
744 1028
745 1029 self.setFile = set - 1
746 1030
747 1031 self.blocksPerFile = blocksPerFile
748 1032
749 1033 self.profilesPerBlock = profilesPerBlock
750 1034
751 1035 if not(self.setNextFile()):
752 1036 print "There isn't a next file"
753 1037 return 0
754 1038
755 1039 self.setBlockDimension()
756 1040
757 1041 return 1
758 1042
759 1043
760 1044
761 1045
762 1046
763 1047
General Comments 0
You need to be logged in to leave comments. Login now