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