##// END OF EJS Templates
schain
RSS
Daniel Valdez -
r500:c6b8e40cf7d6
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,616 +1,617
1 1 '''
2 2 @author: Daniel Suarez
3 3 '''
4 4
5 5 import os
6 6 import sys
7 7 import glob
8 8 import fnmatch
9 9 import datetime
10 10 import time
11 11 import re
12 12 import h5py
13 13 import numpy
14 14
15 15 from model.proc.jroproc_base import ProcessingUnit, Operation
16 16 from model.data.jroamisr import AMISR
17 17
18 18 class RadacHeader():
19 19 def __init__(self, fp):
20 20 header = 'Raw11/Data/RadacHeader'
21 21 self.beamCodeByPulse = fp.get(header+'/BeamCode')
22 22 self.beamCode = fp.get('Raw11/Data/Beamcodes')
23 23 self.code = fp.get(header+'/Code')
24 24 self.frameCount = fp.get(header+'/FrameCount')
25 25 self.modeGroup = fp.get(header+'/ModeGroup')
26 26 self.nsamplesPulse = fp.get(header+'/NSamplesPulse')
27 27 self.pulseCount = fp.get(header+'/PulseCount')
28 28 self.radacTime = fp.get(header+'/RadacTime')
29 29 self.timeCount = fp.get(header+'/TimeCount')
30 30 self.timeStatus = fp.get(header+'/TimeStatus')
31 31
32 32 self.nrecords = self.pulseCount.shape[0] #nblocks
33 33 self.npulses = self.pulseCount.shape[1] #nprofile
34 34 self.nsamples = self.nsamplesPulse[0,0] #ngates
35 35 self.nbeams = self.beamCode.shape[1]
36 36
37 37
38 38 def getIndexRangeToPulse(self, idrecord=0):
39 39 #indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)
40 40 #startPulseCountId = indexToZero[0][0]
41 41 #endPulseCountId = startPulseCountId - 1
42 42 #range1 = numpy.arange(startPulseCountId,self.npulses,1)
43 43 #range2 = numpy.arange(0,startPulseCountId,1)
44 44 #return range1, range2
45 45
46 46 looking_zeros_index = numpy.where(self.pulseCount.value[idrecord,:]==0)[0]
47 47 getLastIndexZero = looking_zeros_index[-1]
48 48 index_data = numpy.arange(0,getLastIndexZero,1)
49 49 index_buffer = numpy.arange(getLastIndexZero,self.npulses,1)
50 50 return index_data, index_buffer
51 51
52 52 class AMISRReader(ProcessingUnit):
53 53
54 54 path = None
55 55 startDate = None
56 56 endDate = None
57 57 startTime = None
58 58 endTime = None
59 59 walk = None
60 60 isConfig = False
61 61
62 62 def __init__(self):
63 63 self.set = None
64 64 self.subset = None
65 65 self.extension_file = '.h5'
66 66 self.dtc_str = 'dtc'
67 67 self.dtc_id = 0
68 68 self.status = True
69 69 self.isConfig = False
70 70 self.dirnameList = []
71 71 self.filenameList = []
72 72 self.fileIndex = None
73 73 self.flagNoMoreFiles = False
74 74 self.flagIsNewFile = 0
75 75 self.filename = ''
76 76 self.amisrFilePointer = None
77 77 self.radacHeaderObj = None
78 78 self.dataOut = self.__createObjByDefault()
79 79 self.datablock = None
80 80 self.rest_datablock = None
81 81 self.range = None
82 82 self.idrecord_count = 0
83 83 self.profileIndex = 0
84 84 self.index_amisr_sample = None
85 85 self.index_amisr_buffer = None
86 86 self.beamCodeByFrame = None
87 87 self.radacTimeByFrame = None
88 88 #atributos originales tal y como esta en el archivo de datos
89 89 self.beamCodesFromFile = None
90 90 self.radacTimeFromFile = None
91 91 self.rangeFromFile = None
92 92 self.dataByFrame = None
93 93 self.dataset = None
94 94
95 95 self.beamCodeDict = {}
96 96 self.beamRangeDict = {}
97 97
98 98 #experiment cgf file
99 99 self.npulsesint_fromfile = None
100 100 self.recordsperfile_fromfile = None
101 101 self.nbeamcodes_fromfile = None
102 102 self.ngates_fromfile = None
103 103 self.ippSeconds_fromfile = None
104 104 self.frequency_h5file = None
105 105
106 106
107 107 self.__firstFile = True
108 108 self.buffer_radactime = None
109 109
110 110 self.index4_schain_datablock = None
111 111 self.index4_buffer = None
112 112 self.schain_datablock = None
113 113 self.buffer = None
114 114 self.linear_pulseCount = None
115 115 self.npulseByFrame = None
116 116 self.profileIndex_offset = None
117 117 self.timezone = 'ut'
118 118
119 119 def __createObjByDefault(self):
120 120
121 121 dataObj = AMISR()
122 122
123 123 return dataObj
124 124
125 125 def __setParameters(self,path,startDate,endDate,startTime,endTime,walk):
126 126 self.path = path
127 127 self.startDate = startDate
128 128 self.endDate = endDate
129 129 self.startTime = startTime
130 130 self.endTime = endTime
131 131 self.walk = walk
132 132
133 133 def __checkPath(self):
134 134 if os.path.exists(self.path):
135 135 self.status = 1
136 136 else:
137 137 self.status = 0
138 138 print 'Path:%s does not exists'%self.path
139 139
140 140 return
141 141
142 142 def __selDates(self, amisr_dirname_format):
143 143 try:
144 144 year = int(amisr_dirname_format[0:4])
145 145 month = int(amisr_dirname_format[4:6])
146 146 dom = int(amisr_dirname_format[6:8])
147 147 thisDate = datetime.date(year,month,dom)
148 148
149 149 if (thisDate>=self.startDate and thisDate <= self.endDate):
150 150 return amisr_dirname_format
151 151 except:
152 152 return None
153 153
154 154 def __findDataForDates(self):
155 155
156 156
157 157
158 158 if not(self.status):
159 159 return None
160 160
161 161 pat = '\d+.\d+'
162 162 dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
163 163 dirnameList = filter(lambda x:x!=None,dirnameList)
164 164 dirnameList = [x.string for x in dirnameList]
165 165 dirnameList = [self.__selDates(x) for x in dirnameList]
166 166 dirnameList = filter(lambda x:x!=None,dirnameList)
167 167 if len(dirnameList)>0:
168 168 self.status = 1
169 169 self.dirnameList = dirnameList
170 170 self.dirnameList.sort()
171 171 else:
172 172 self.status = 0
173 173 return None
174 174
175 175 def __getTimeFromData(self):
176 176 startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
177 177 endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
178 178
179 179 print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader)
180 180 print '........................................'
181 181 filter_filenameList = []
182 for filename in self.filenameList:
182 for i in range(len(self.filenameList)-1):
183 filename = self.filenameList[i]
183 184 fp = h5py.File(filename,'r')
184 185 time_str = fp.get('Time/RadacTimeString')
185 186
186 187 startDateTimeStr_File = time_str[0][0].split('.')[0]
187 188 junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
188 189 startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
189 190
190 191 endDateTimeStr_File = time_str[-1][-1].split('.')[0]
191 192 junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
192 193 endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
193 194
194 195 fp.close()
195 196
196 197 if self.timezone == 'lt':
197 198 startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
198 199 endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300)
199 200
200 201 if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader):
201 202 #self.filenameList.remove(filename)
202 203 filter_filenameList.append(filename)
203 204
204 205 filter_filenameList.sort()
205 206 self.filenameList = filter_filenameList
206 207 return 1
207 208
208 209 def __filterByGlob1(self, dirName):
209 210 filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)
210 211 filterDict = {}
211 212 filterDict.setdefault(dirName)
212 213 filterDict[dirName] = filter_files
213 214 return filterDict
214 215
215 216 def __getFilenameList(self, fileListInKeys, dirList):
216 217 for value in fileListInKeys:
217 218 dirName = value.keys()[0]
218 219 for file in value[dirName]:
219 220 filename = os.path.join(dirName, file)
220 221 self.filenameList.append(filename)
221 222
222 223
223 224 def __selectDataForTimes(self):
224 225 #aun no esta implementado el filtro for tiempo
225 226 if not(self.status):
226 227 return None
227 228
228 229 dirList = [os.path.join(self.path,x) for x in self.dirnameList]
229 230
230 231 fileListInKeys = [self.__filterByGlob1(x) for x in dirList]
231 232
232 233 self.__getFilenameList(fileListInKeys, dirList)
233 234 #filtro por tiempo
234 235 if not(self.all):
235 236 self.__getTimeFromData()
236 237
237 238
238 239 if len(self.filenameList)>0:
239 240 self.status = 1
240 241 self.filenameList.sort()
241 242 else:
242 243 self.status = 0
243 244 return None
244 245
245 246
246 247 def __searchFilesOffline(self,
247 248 path,
248 249 startDate,
249 250 endDate,
250 251 startTime=datetime.time(0,0,0),
251 252 endTime=datetime.time(23,59,59),
252 253 walk=True):
253 254
254 255 self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
255 256
256 257 self.__checkPath()
257 258
258 259 self.__findDataForDates()
259 260
260 261 self.__selectDataForTimes()
261 262
262 263 for i in range(len(self.filenameList)):
263 264 print "%s" %(self.filenameList[i])
264 265
265 266 return
266 267
267 268 def __setNextFileOffline(self):
268 269 idFile = self.fileIndex
269 270
270 271 while (True):
271 272 idFile += 1
272 273 if not(idFile < len(self.filenameList)):
273 274 self.flagNoMoreFiles = 1
274 275 print "No more Files"
275 276 return 0
276 277
277 278 filename = self.filenameList[idFile]
278 279
279 280 amisrFilePointer = h5py.File(filename,'r')
280 281
281 282 break
282 283
283 284 self.flagIsNewFile = 1
284 285 self.fileIndex = idFile
285 286 self.filename = filename
286 287
287 288 self.amisrFilePointer = amisrFilePointer
288 289
289 290 print "Setting the file: %s"%self.filename
290 291
291 292 return 1
292 293
293 294 def __readHeader(self):
294 295 self.radacHeaderObj = RadacHeader(self.amisrFilePointer)
295 296
296 297 #update values from experiment cfg file
297 298 if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile:
298 299 self.radacHeaderObj.nrecords = self.recordsperfile_fromfile
299 300 self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile
300 301 self.radacHeaderObj.npulses = self.npulsesint_fromfile
301 302 self.radacHeaderObj.nsamples = self.ngates_fromfile
302 303
303 304 #looking index list for data
304 305 start_index = self.radacHeaderObj.pulseCount[0,:][0]
305 306 end_index = self.radacHeaderObj.npulses
306 307 range4data = range(start_index, end_index)
307 308 self.index4_schain_datablock = numpy.array(range4data)
308 309
309 310 buffer_start_index = 0
310 311 buffer_end_index = self.radacHeaderObj.pulseCount[0,:][0]
311 312 range4buffer = range(buffer_start_index, buffer_end_index)
312 313 self.index4_buffer = numpy.array(range4buffer)
313 314
314 315 self.linear_pulseCount = numpy.array(range4data + range4buffer)
315 316 self.npulseByFrame = max(self.radacHeaderObj.pulseCount[0,:]+1)
316 317
317 318 #get tuning frequency
318 319 frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency')
319 320 self.frequency_h5file = frequency_h5file_dataset[0,0]
320 321
321 322 self.flagIsNewFile = 1
322 323
323 324 def __getBeamCode(self):
324 325 self.beamCodeDict = {}
325 326 self.beamRangeDict = {}
326 327
327 328 beamCodeMap = self.amisrFilePointer.get('Setup/BeamcodeMap')
328 329
329 330 for i in range(len(self.radacHeaderObj.beamCode[0,:])):
330 331 self.beamCodeDict.setdefault(i)
331 332 self.beamRangeDict.setdefault(i)
332 333 beamcodeValue = self.radacHeaderObj.beamCode[0,i]
333 334 beamcodeIndex = numpy.where(beamCodeMap[:,0] == beamcodeValue)[0][0]
334 335 x = beamCodeMap[beamcodeIndex][1]
335 336 y = beamCodeMap[beamcodeIndex][2]
336 337 z = beamCodeMap[beamcodeIndex][3]
337 338 self.beamCodeDict[i] = [beamcodeValue, x, y, z]
338 339
339 340 just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:]
340 341
341 342 for i in range(len(self.beamCodeDict.values())):
342 343 xx = numpy.where(just4record0==self.beamCodeDict.values()[i][0])
343 344 self.beamRangeDict[i] = xx[0]
344 345
345 346 def __getExpParameters(self):
346 347 if not(self.status):
347 348 return None
348 349
349 350 experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup')
350 351
351 352 expFinder = glob.glob1(experimentCfgPath,'*.exp')
352 353 if len(expFinder)== 0:
353 354 self.status = 0
354 355 return None
355 356
356 357 experimentFilename = os.path.join(experimentCfgPath,expFinder[0])
357 358
358 359 f = open(experimentFilename)
359 360 lines = f.readlines()
360 361 f.close()
361 362
362 363 parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*']
363 364 filterList = [fnmatch.filter(lines, x) for x in parmsList]
364 365
365 366
366 367 values = [re.sub(r'\D',"",x[0]) for x in filterList]
367 368
368 369 self.npulsesint_fromfile = int(values[0])
369 370 self.recordsperfile_fromfile = int(values[1])
370 371 self.nbeamcodes_fromfile = int(values[2])
371 372 self.ngates_fromfile = int(values[3])
372 373
373 374 tufileFinder = fnmatch.filter(lines, 'tufile=*')
374 375 tufile = tufileFinder[0].split('=')[1].split('\n')[0]
375 376 tufile = tufile.split('\r')[0]
376 377 tufilename = os.path.join(experimentCfgPath,tufile)
377 378
378 379 f = open(tufilename)
379 380 lines = f.readlines()
380 381 f.close()
381 382 self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6
382 383
383 384
384 385 self.status = 1
385 386
386 387 def __setIdsAndArrays(self):
387 388 self.dataByFrame = self.__setDataByFrame()
388 389 self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[0, :]
389 390 self.readRanges()
390 391 self.index_amisr_sample, self.index_amisr_buffer = self.radacHeaderObj.getIndexRangeToPulse(0)
391 392 self.radacTimeByFrame = numpy.zeros(self.radacHeaderObj.npulses)
392 393 self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame)
393 394
394 395
395 396 def __setNextFile(self):
396 397
397 398 newFile = self.__setNextFileOffline()
398 399
399 400 if not(newFile):
400 401 return 0
401 402
402 403 self.__readHeader()
403 404
404 405 if self.__firstFile:
405 406 self.__setIdsAndArrays()
406 407 self.__firstFile = False
407 408
408 409 self.__getBeamCode()
409 410 self.readDataBlock()
410 411
411 412
412 413 def setup(self,path=None,
413 414 startDate=None,
414 415 endDate=None,
415 416 startTime=datetime.time(0,0,0),
416 417 endTime=datetime.time(23,59,59),
417 418 walk=True,
418 419 timezone='ut',
419 420 all=0,):
420 421
421 422 self.timezone = timezone
422 423 self.all = all
423 424 #Busqueda de archivos offline
424 425 self.__searchFilesOffline(path, startDate, endDate, startTime, endTime, walk)
425 426
426 427 if not(self.filenameList):
427 428 print "There is no files into the folder: %s"%(path)
428 429
429 430 sys.exit(-1)
430 431
431 432 self.__getExpParameters()
432 433
433 434 self.fileIndex = -1
434 435
435 436 self.__setNextFile()
436 437
437 438 first_beamcode = self.radacHeaderObj.beamCodeByPulse[0,0]
438 439 index = numpy.where(self.radacHeaderObj.beamCodeByPulse[0,:]!=first_beamcode)[0][0]
439 440 self.profileIndex_offset = self.radacHeaderObj.pulseCount[0,:][index]
440 441 self.profileIndex = self.profileIndex_offset
441 442
442 443 def readRanges(self):
443 444 dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range')
444 445 #self.rangeFromFile = dataset.value
445 446 self.rangeFromFile = numpy.reshape(dataset.value,(-1))
446 447 return range
447 448
448 449
449 450 def readRadacTime(self,idrecord, range1, range2):
450 451 self.radacTimeFromFile = self.radacHeaderObj.radacTime.value
451 452
452 453 radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
453 454 #radacTimeByFrame = dataset[idrecord - 1,range1]
454 455 #radacTimeByFrame = dataset[idrecord,range2]
455 456
456 457 return radacTimeByFrame
457 458
458 459 def readBeamCode(self, idrecord, range1, range2):
459 460 dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode')
460 461 beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
461 462 self.beamCodesFromFile = dataset.value
462 463
463 464 #beamcodeByFrame[range1] = dataset[idrecord - 1, range1]
464 465 #beamcodeByFrame[range2] = dataset[idrecord, range2]
465 466 beamcodeByFrame[range1] = dataset[idrecord, range1]
466 467 beamcodeByFrame[range2] = dataset[idrecord, range2]
467 468
468 469 return beamcodeByFrame
469 470
470 471
471 472 def __setDataByFrame(self):
472 473 ndata = 2 # porque es complejo
473 474 dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata))
474 475 return dataByFrame
475 476
476 477 def __readDataSet(self):
477 478 dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data')
478 479 return dataset
479 480
480 481 def __setDataBlock(self,):
481 482 real = self.dataByFrame[:,:,0] #asumo que 0 es real
482 483 imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario
483 484 datablock = real + imag*1j #armo el complejo
484 485 return datablock
485 486
486 487 def readSamples_version1(self,idrecord):
487 488 #estas tres primeras lineas solo se deben ejecutar una vez
488 489 if self.flagIsNewFile:
489 490 #reading dataset
490 491 self.dataset = self.__readDataSet()
491 492 self.flagIsNewFile = 0
492 493
493 494 if idrecord == 0:
494 495 self.dataByFrame[self.index4_schain_datablock, : ,:] = self.dataset[0, self.index_amisr_sample,:,:]
495 496 self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[0, self.index_amisr_sample]
496 497 datablock = self.__setDataBlock()
497 498
498 499 self.buffer = self.dataset[0, self.index_amisr_buffer,:,:]
499 500 self.buffer_radactime = self.radacHeaderObj.radacTime[0, self.index_amisr_buffer]
500 501
501 502 return datablock
502 503
503 504 self.dataByFrame[self.index4_buffer,:,:] = self.buffer.copy()
504 505 self.radacTimeByFrame[self.index4_buffer] = self.buffer_radactime.copy()
505 506 self.dataByFrame[self.index4_schain_datablock,:,:] = self.dataset[idrecord, self.index_amisr_sample,:,:]
506 507 self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_sample]
507 508 datablock = self.__setDataBlock()
508 509
509 510 self.buffer = self.dataset[idrecord, self.index_amisr_buffer, :, :]
510 511 self.buffer_radactime = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_buffer]
511 512
512 513 return datablock
513 514
514 515
515 516 def readSamples(self,idrecord):
516 517 if self.flagIsNewFile:
517 518 self.dataByFrame = self.__setDataByFrame()
518 519 self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :]
519 520
520 521 #reading ranges
521 522 self.readRanges()
522 523 #reading dataset
523 524 self.dataset = self.__readDataSet()
524 525
525 526 self.flagIsNewFile = 0
526 527 self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :]
527 528 self.dataByFrame = self.dataset[idrecord, :, :, :]
528 529 datablock = self.__setDataBlock()
529 530 return datablock
530 531
531 532
532 533 def readDataBlock(self):
533 534
534 535 self.datablock = self.readSamples_version1(self.idrecord_count)
535 536 #self.datablock = self.readSamples(self.idrecord_count)
536 537 #print 'record:', self.idrecord_count
537 538
538 539 self.idrecord_count += 1
539 540 self.profileIndex = 0
540 541
541 542 if self.idrecord_count >= self.radacHeaderObj.nrecords:
542 543 self.idrecord_count = 0
543 544 self.flagIsNewFile = 1
544 545
545 546 def readNextBlock(self):
546 547
547 548 self.readDataBlock()
548 549
549 550 if self.flagIsNewFile:
550 551 self.__setNextFile()
551 552 pass
552 553
553 554 def __hasNotDataInBuffer(self):
554 555 #self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record
555 556 if self.profileIndex >= self.radacHeaderObj.npulses:
556 557 return 1
557 558 return 0
558 559
559 560 def printUTC(self):
560 561 print self.dataOut.utctime
561 562 print ''
562 563
563 564 def setObjProperties(self):
564 565 self.dataOut.heightList = self.rangeFromFile/1000.0 #km
565 566 self.dataOut.nProfiles = self.radacHeaderObj.npulses
566 567 self.dataOut.nRecords = self.radacHeaderObj.nrecords
567 568 self.dataOut.nBeams = self.radacHeaderObj.nbeams
568 569 self.dataOut.ippSeconds = self.ippSeconds_fromfile
569 570 self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
570 571 self.dataOut.frequency = self.frequency_h5file
571 572 self.dataOut.npulseByFrame = self.npulseByFrame
572 573 self.dataOut.nBaud = None
573 574 self.dataOut.nCode = None
574 575 self.dataOut.code = None
575 576
576 577 self.dataOut.beamCodeDict = self.beamCodeDict
577 578 self.dataOut.beamRangeDict = self.beamRangeDict
578 579
579 580 if self.timezone == 'lt':
580 581 self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes
581 582 else:
582 583 self.dataOut.timeZone = 0 #by default time is UTC
583 584
584 585 def getData(self):
585 586
586 587 if self.flagNoMoreFiles:
587 588 self.dataOut.flagNoData = True
588 589 print 'Process finished'
589 590 return 0
590 591
591 592 if self.__hasNotDataInBuffer():
592 593 self.readNextBlock()
593 594
594 595
595 596 if self.datablock == None: # setear esta condicion cuando no hayan datos por leers
596 597 self.dataOut.flagNoData = True
597 598 return 0
598 599
599 600 self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1))
600 601
601 602 self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex]
602 603
603 604 self.dataOut.flagNoData = False
604 605
605 606 self.profileIndex += 1
606 607
607 608 return self.dataOut.data
608 609
609 610
610 611 def run(self, **kwargs):
611 612 if not(self.isConfig):
612 613 self.setup(**kwargs)
613 614 self.setObjProperties()
614 615 self.isConfig = True
615 616
616 617 self.getData()
General Comments 0
You need to be logged in to leave comments. Login now