##// END OF EJS Templates
schain
RSS
se agregan variables para salvar graficos en disco para el ultimo bloque de datos
Daniel Valdez -
r457:2445b97595f3
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,641 +1,645
1 1 '''
2 2
3 3 $Author: murco $
4 4 $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
5 5 '''
6 6
7 7 import os, sys
8 8 import copy
9 9 import numpy
10 10 import datetime
11 11
12 12 from jroheaderIO import SystemHeader, RadarControllerHeader
13 13
14 14
15 15 def hildebrand_sekhon(data, navg):
16 16
17 17 data = data.copy()
18 18
19 19 sortdata = numpy.sort(data,axis=None)
20 20 lenOfData = len(sortdata)
21 21 nums_min = lenOfData/10
22 22
23 23 if (lenOfData/10) > 2:
24 24 nums_min = lenOfData/10
25 25 else:
26 26 nums_min = 2
27 27
28 28 sump = 0.
29 29
30 30 sumq = 0.
31 31
32 32 j = 0
33 33
34 34 cont = 1
35 35
36 36 while((cont==1)and(j<lenOfData)):
37 37
38 38 sump += sortdata[j]
39 39
40 40 sumq += sortdata[j]**2
41 41
42 42 j += 1
43 43
44 44 if j > nums_min:
45 45 rtest = float(j)/(j-1) + 1.0/navg
46 46 if ((sumq*j) > (rtest*sump**2)):
47 47 j = j - 1
48 48 sump = sump - sortdata[j]
49 49 sumq = sumq - sortdata[j]**2
50 50 cont = 0
51 51
52 52 lnoise = sump /j
53 53 stdv = numpy.sqrt((sumq - lnoise**2)/(j - 1))
54 54 return lnoise
55 55
56 56 class JROData:
57 57
58 58 # m_BasicHeader = BasicHeader()
59 59 # m_ProcessingHeader = ProcessingHeader()
60 60
61 61 systemHeaderObj = SystemHeader()
62 62
63 63 radarControllerHeaderObj = RadarControllerHeader()
64 64
65 65 # data = None
66 66
67 67 type = None
68 68
69 69 dtype = None
70 70
71 71 # nChannels = None
72 72
73 73 # nHeights = None
74 74
75 75 nProfiles = None
76 76
77 77 heightList = None
78 78
79 79 channelList = None
80 80
81 81 flagNoData = True
82 82
83 83 flagTimeBlock = False
84 84
85 85 useLocalTime = False
86 86
87 87 utctime = None
88 88
89 89 timeZone = None
90 90
91 91 dstFlag = None
92 92
93 93 errorCount = None
94 94
95 95 blocksize = None
96 96
97 97 nCode = None
98 98
99 99 nBaud = None
100 100
101 101 code = None
102 102
103 103 flagDecodeData = False #asumo q la data no esta decodificada
104 104
105 105 flagDeflipData = False #asumo q la data no esta sin flip
106 106
107 107 flagShiftFFT = False
108 108
109 109 ippSeconds = None
110 110
111 111 timeInterval = None
112 112
113 113 nCohInt = None
114 114
115 115 noise = None
116 116
117 117 windowOfFilter = 1
118 118
119 119 #Speed of ligth
120 120 C = 3e8
121 121
122 122 frequency = 49.92e6
123 123
124 124 realtime = False
125 125
126 126 beacon_heiIndexList = None
127 127
128 last_block = None
129
130 blocknow = None
131
128 132 def __init__(self):
129 133
130 134 raise ValueError, "This class has not been implemented"
131 135
132 136 def copy(self, inputObj=None):
133 137
134 138 if inputObj == None:
135 139 return copy.deepcopy(self)
136 140
137 141 for key in inputObj.__dict__.keys():
138 142 self.__dict__[key] = inputObj.__dict__[key]
139 143
140 144 def deepcopy(self):
141 145
142 146 return copy.deepcopy(self)
143 147
144 148 def isEmpty(self):
145 149
146 150 return self.flagNoData
147 151
148 152 def getNoise(self):
149 153
150 154 raise ValueError, "Not implemented"
151 155
152 156 def getNChannels(self):
153 157
154 158 return len(self.channelList)
155 159
156 160 def getChannelIndexList(self):
157 161
158 162 return range(self.nChannels)
159 163
160 164 def getNHeights(self):
161 165
162 166 return len(self.heightList)
163 167
164 168 def getHeiRange(self, extrapoints=0):
165 169
166 170 heis = self.heightList
167 171 # deltah = self.heightList[1] - self.heightList[0]
168 172 #
169 173 # heis.append(self.heightList[-1])
170 174
171 175 return heis
172 176
173 177 def getltctime(self):
174 178
175 179 if self.useLocalTime:
176 180 return self.utctime - self.timeZone*60
177 181
178 182 return self.utctime
179 183
180 184 def getDatatime(self):
181 185
182 186 datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
183 187 return datatime
184 188
185 189 def getTimeRange(self):
186 190
187 191 datatime = []
188 192
189 193 datatime.append(self.ltctime)
190 194 datatime.append(self.ltctime + self.timeInterval)
191 195
192 196 datatime = numpy.array(datatime)
193 197
194 198 return datatime
195 199
196 200 def getFmax(self):
197 201
198 202 PRF = 1./(self.ippSeconds * self.nCohInt)
199 203
200 204 fmax = PRF/2.
201 205
202 206 return fmax
203 207
204 208 def getVmax(self):
205 209
206 210 _lambda = self.C/self.frequency
207 211
208 212 vmax = self.getFmax() * _lambda
209 213
210 214 return vmax
211 215
212 216 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
213 217 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
214 218 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
215 219 noise = property(getNoise, "I'm the 'nHeights' property.")
216 220 datatime = property(getDatatime, "I'm the 'datatime' property")
217 221 ltctime = property(getltctime, "I'm the 'ltctime' property")
218 222
219 223 class Voltage(JROData):
220 224
221 225 #data es un numpy array de 2 dmensiones (canales, alturas)
222 226 data = None
223 227
224 228 def __init__(self):
225 229 '''
226 230 Constructor
227 231 '''
228 232
229 233 self.radarControllerHeaderObj = RadarControllerHeader()
230 234
231 235 self.systemHeaderObj = SystemHeader()
232 236
233 237 self.type = "Voltage"
234 238
235 239 self.data = None
236 240
237 241 self.dtype = None
238 242
239 243 # self.nChannels = 0
240 244
241 245 # self.nHeights = 0
242 246
243 247 self.nProfiles = None
244 248
245 249 self.heightList = None
246 250
247 251 self.channelList = None
248 252
249 253 # self.channelIndexList = None
250 254
251 255 self.flagNoData = True
252 256
253 257 self.flagTimeBlock = False
254 258
255 259 self.utctime = None
256 260
257 261 self.timeZone = None
258 262
259 263 self.dstFlag = None
260 264
261 265 self.errorCount = None
262 266
263 267 self.nCohInt = None
264 268
265 269 self.blocksize = None
266 270
267 271 self.flagDecodeData = False #asumo q la data no esta decodificada
268 272
269 273 self.flagDeflipData = False #asumo q la data no esta sin flip
270 274
271 275 self.flagShiftFFT = False
272 276
273 277
274 278 def getNoisebyHildebrand(self):
275 279 """
276 280 Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
277 281
278 282 Return:
279 283 noiselevel
280 284 """
281 285
282 286 for channel in range(self.nChannels):
283 287 daux = self.data_spc[channel,:,:]
284 288 self.noise[channel] = hildebrand_sekhon(daux, self.nCohInt)
285 289
286 290 return self.noise
287 291
288 292 def getNoise(self, type = 1):
289 293
290 294 self.noise = numpy.zeros(self.nChannels)
291 295
292 296 if type == 1:
293 297 noise = self.getNoisebyHildebrand()
294 298
295 299 return 10*numpy.log10(noise)
296 300
297 301 class Spectra(JROData):
298 302
299 303 #data es un numpy array de 2 dmensiones (canales, perfiles, alturas)
300 304 data_spc = None
301 305
302 306 #data es un numpy array de 2 dmensiones (canales, pares, alturas)
303 307 data_cspc = None
304 308
305 309 #data es un numpy array de 2 dmensiones (canales, alturas)
306 310 data_dc = None
307 311
308 312 nFFTPoints = None
309 313
310 314 nPairs = None
311 315
312 316 pairsList = None
313 317
314 318 nIncohInt = None
315 319
316 320 wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia
317 321
318 322 nCohInt = None #se requiere para determinar el valor de timeInterval
319 323
320 324 ippFactor = None
321 325
322 326 def __init__(self):
323 327 '''
324 328 Constructor
325 329 '''
326 330
327 331 self.radarControllerHeaderObj = RadarControllerHeader()
328 332
329 333 self.systemHeaderObj = SystemHeader()
330 334
331 335 self.type = "Spectra"
332 336
333 337 # self.data = None
334 338
335 339 self.dtype = None
336 340
337 341 # self.nChannels = 0
338 342
339 343 # self.nHeights = 0
340 344
341 345 self.nProfiles = None
342 346
343 347 self.heightList = None
344 348
345 349 self.channelList = None
346 350
347 351 # self.channelIndexList = None
348 352
349 353 self.flagNoData = True
350 354
351 355 self.flagTimeBlock = False
352 356
353 357 self.utctime = None
354 358
355 359 self.nCohInt = None
356 360
357 361 self.nIncohInt = None
358 362
359 363 self.blocksize = None
360 364
361 365 self.nFFTPoints = None
362 366
363 367 self.wavelength = None
364 368
365 369 self.flagDecodeData = False #asumo q la data no esta decodificada
366 370
367 371 self.flagDeflipData = False #asumo q la data no esta sin flip
368 372
369 373 self.flagShiftFFT = False
370 374
371 375 self.ippFactor = 1
372 376
373 377 self.noise = None
374 378
375 379 self.beacon_heiIndexList = []
376 380
377 381
378 382 def getNoisebyHildebrand(self):
379 383 """
380 384 Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
381 385
382 386 Return:
383 387 noiselevel
384 388 """
385 389 noise = numpy.zeros(self.nChannels)
386 390 for channel in range(self.nChannels):
387 391 daux = self.data_spc[channel,:,:]
388 392 noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
389 393
390 394 return noise
391 395
392 396 def getNoise(self):
393 397 if self.noise != None:
394 398 return self.noise
395 399 else:
396 400 noise = self.getNoisebyHildebrand()
397 401 return noise
398 402
399 403
400 404 def getFreqRange(self, extrapoints=0):
401 405
402 406 deltafreq = self.getFmax() / (self.nFFTPoints*self.ippFactor)
403 407 freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
404 408
405 409 return freqrange
406 410
407 411 def getVelRange(self, extrapoints=0):
408 412
409 413 deltav = self.getVmax() / (self.nFFTPoints*self.ippFactor)
410 414 velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltav/2
411 415
412 416 return velrange
413 417
414 418 def getNPairs(self):
415 419
416 420 return len(self.pairsList)
417 421
418 422 def getPairsIndexList(self):
419 423
420 424 return range(self.nPairs)
421 425
422 426 def getNormFactor(self):
423 427 pwcode = 1
424 428 if self.flagDecodeData:
425 429 pwcode = numpy.sum(self.code[0]**2)
426 430 normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode
427 431
428 432 return normFactor
429 433
430 434 def getFlagCspc(self):
431 435
432 436 if self.data_cspc == None:
433 437 return True
434 438
435 439 return False
436 440
437 441 def getFlagDc(self):
438 442
439 443 if self.data_dc == None:
440 444 return True
441 445
442 446 return False
443 447
444 448 nPairs = property(getNPairs, "I'm the 'nPairs' property.")
445 449 pairsIndexList = property(getPairsIndexList, "I'm the 'pairsIndexList' property.")
446 450 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
447 451 flag_cspc = property(getFlagCspc)
448 452 flag_dc = property(getFlagDc)
449 453
450 454 class SpectraHeis(JROData):
451 455
452 456 data_spc = None
453 457
454 458 data_cspc = None
455 459
456 460 data_dc = None
457 461
458 462 nFFTPoints = None
459 463
460 464 nPairs = None
461 465
462 466 pairsList = None
463 467
464 468 nIncohInt = None
465 469
466 470 def __init__(self):
467 471
468 472 self.radarControllerHeaderObj = RadarControllerHeader()
469 473
470 474 self.systemHeaderObj = SystemHeader()
471 475
472 476 self.type = "SpectraHeis"
473 477
474 478 self.dtype = None
475 479
476 480 # self.nChannels = 0
477 481
478 482 # self.nHeights = 0
479 483
480 484 self.nProfiles = None
481 485
482 486 self.heightList = None
483 487
484 488 self.channelList = None
485 489
486 490 # self.channelIndexList = None
487 491
488 492 self.flagNoData = True
489 493
490 494 self.flagTimeBlock = False
491 495
492 496 self.nPairs = 0
493 497
494 498 self.utctime = None
495 499
496 500 self.blocksize = None
497 501
498 502 class Fits:
499 503
500 504 heightList = None
501 505
502 506 channelList = None
503 507
504 508 flagNoData = True
505 509
506 510 flagTimeBlock = False
507 511
508 512 useLocalTime = False
509 513
510 514 utctime = None
511 515
512 516 timeZone = None
513 517
514 518 ippSeconds = None
515 519
516 520 timeInterval = None
517 521
518 522 nCohInt = None
519 523
520 524 nIncohInt = None
521 525
522 526 noise = None
523 527
524 528 windowOfFilter = 1
525 529
526 530 #Speed of ligth
527 531 C = 3e8
528 532
529 533 frequency = 49.92e6
530 534
531 535 realtime = False
532 536
533 537
534 538 def __init__(self):
535 539
536 540 self.type = "Fits"
537 541
538 542 self.nProfiles = None
539 543
540 544 self.heightList = None
541 545
542 546 self.channelList = None
543 547
544 548 # self.channelIndexList = None
545 549
546 550 self.flagNoData = True
547 551
548 552 self.utctime = None
549 553
550 554 self.nCohInt = None
551 555
552 556 self.nIncohInt = None
553 557
554 558 self.useLocalTime = True
555 559
556 560 # self.utctime = None
557 561 # self.timeZone = None
558 562 # self.ltctime = None
559 563 # self.timeInterval = None
560 564 # self.header = None
561 565 # self.data_header = None
562 566 # self.data = None
563 567 # self.datatime = None
564 568 # self.flagNoData = False
565 569 # self.expName = ''
566 570 # self.nChannels = None
567 571 # self.nSamples = None
568 572 # self.dataBlocksPerFile = None
569 573 # self.comments = ''
570 574 #
571 575
572 576
573 577 def getltctime(self):
574 578
575 579 if self.useLocalTime:
576 580 return self.utctime - self.timeZone*60
577 581
578 582 return self.utctime
579 583
580 584 def getDatatime(self):
581 585
582 586 datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
583 587 return datatime
584 588
585 589 def getTimeRange(self):
586 590
587 591 datatime = []
588 592
589 593 datatime.append(self.ltctime)
590 594 datatime.append(self.ltctime + self.timeInterval)
591 595
592 596 datatime = numpy.array(datatime)
593 597
594 598 return datatime
595 599
596 600 def getHeiRange(self):
597 601
598 602 heis = self.heightList
599 603
600 604 return heis
601 605
602 606 def isEmpty(self):
603 607
604 608 return self.flagNoData
605 609
606 610 def getNHeights(self):
607 611
608 612 return len(self.heightList)
609 613
610 614 def getNChannels(self):
611 615
612 616 return len(self.channelList)
613 617
614 618 def getChannelIndexList(self):
615 619
616 620 return range(self.nChannels)
617 621
618 622 def getNoise(self, type = 1):
619 623
620 624 self.noise = numpy.zeros(self.nChannels)
621 625
622 626 if type == 1:
623 627 noise = self.getNoisebyHildebrand()
624 628
625 629 if type == 2:
626 630 noise = self.getNoisebySort()
627 631
628 632 if type == 3:
629 633 noise = self.getNoisebyWindow()
630 634
631 635 return noise
632 636
633 637 datatime = property(getDatatime, "I'm the 'datatime' property")
634 638 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
635 639 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
636 640 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
637 641 noise = property(getNoise, "I'm the 'nHeights' property.")
638 642 datatime = property(getDatatime, "I'm the 'datatime' property")
639 643 ltctime = property(getltctime, "I'm the 'ltctime' property")
640 644
641 645 ltctime = property(getltctime, "I'm the 'ltctime' property") No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,3413 +1,3418
1 1 '''
2 2
3 3 $Author: murco $
4 4 $Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
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 from xml.etree.ElementTree import Element, SubElement, ElementTree
14 14 try:
15 15 import pyfits
16 16 except:
17 17 print "pyfits module has not been imported, it should be installed to save files in fits format"
18 18
19 19 from jrodata import *
20 20 from jroheaderIO import *
21 21 from jroprocessing import *
22 22
23 23 LOCALTIME = True #-18000
24 24
25 25 def isNumber(str):
26 26 """
27 27 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
28 28
29 29 Excepciones:
30 30 Si un determinado string no puede ser convertido a numero
31 31 Input:
32 32 str, string al cual se le analiza para determinar si convertible a un numero o no
33 33
34 34 Return:
35 35 True : si el string es uno numerico
36 36 False : no es un string numerico
37 37 """
38 38 try:
39 39 float( str )
40 40 return True
41 41 except:
42 42 return False
43 43
44 44 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
45 45 """
46 46 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
47 47
48 48 Inputs:
49 49 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
50 50
51 51 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
52 52 segundos contados desde 01/01/1970.
53 53 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
54 54 segundos contados desde 01/01/1970.
55 55
56 56 Return:
57 57 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
58 58 fecha especificado, de lo contrario retorna False.
59 59
60 60 Excepciones:
61 61 Si el archivo no existe o no puede ser abierto
62 62 Si la cabecera no puede ser leida.
63 63
64 64 """
65 65 basicHeaderObj = BasicHeader(LOCALTIME)
66 66
67 67 try:
68 68 fp = open(filename,'rb')
69 69 except:
70 70 raise IOError, "The file %s can't be opened" %(filename)
71 71
72 72 sts = basicHeaderObj.read(fp)
73 73 fp.close()
74 74
75 75 if not(sts):
76 76 print "Skipping the file %s because it has not a valid header" %(filename)
77 77 return 0
78 78
79 79 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
80 80 return 0
81 81
82 82 return 1
83 83
84 84 def isFileinThisTime(filename, startTime, endTime):
85 85 """
86 86 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
87 87
88 88 Inputs:
89 89 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
90 90
91 91 startTime : tiempo inicial del rango seleccionado en formato datetime.time
92 92
93 93 endTime : tiempo final del rango seleccionado en formato datetime.time
94 94
95 95 Return:
96 96 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
97 97 fecha especificado, de lo contrario retorna False.
98 98
99 99 Excepciones:
100 100 Si el archivo no existe o no puede ser abierto
101 101 Si la cabecera no puede ser leida.
102 102
103 103 """
104 104
105 105
106 106 try:
107 107 fp = open(filename,'rb')
108 108 except:
109 109 raise IOError, "The file %s can't be opened" %(filename)
110 110
111 111 basicHeaderObj = BasicHeader(LOCALTIME)
112 112 sts = basicHeaderObj.read(fp)
113 113 fp.close()
114 114
115 115 thisDatetime = basicHeaderObj.datatime
116 116 thisTime = basicHeaderObj.datatime.time()
117 117
118 118 if not(sts):
119 119 print "Skipping the file %s because it has not a valid header" %(filename)
120 120 return None
121 121
122 122 if not ((startTime <= thisTime) and (endTime > thisTime)):
123 123 return None
124 124
125 125 return thisDatetime
126 126
127 127 def getFileFromSet(path,ext,set):
128 128 validFilelist = []
129 129 fileList = os.listdir(path)
130 130
131 131 # 0 1234 567 89A BCDE
132 132 # H YYYY DDD SSS .ext
133 133
134 134 for file in fileList:
135 135 try:
136 136 year = int(file[1:5])
137 137 doy = int(file[5:8])
138 138
139 139
140 140 except:
141 141 continue
142 142
143 143 if (os.path.splitext(file)[-1].lower() != ext.lower()):
144 144 continue
145 145
146 146 validFilelist.append(file)
147 147
148 148 myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
149 149
150 150 if len(myfile)!= 0:
151 151 return myfile[0]
152 152 else:
153 153 filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower())
154 154 print 'the filename %s does not exist'%filename
155 155 print '...going to the last file: '
156 156
157 157 if validFilelist:
158 158 validFilelist = sorted( validFilelist, key=str.lower )
159 159 return validFilelist[-1]
160 160
161 161 return None
162 162
163 163
164 164 def getlastFileFromPath(path, ext):
165 165 """
166 166 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
167 167 al final de la depuracion devuelve el ultimo file de la lista que quedo.
168 168
169 169 Input:
170 170 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
171 171 ext : extension de los files contenidos en una carpeta
172 172
173 173 Return:
174 174 El ultimo file de una determinada carpeta, no se considera el path.
175 175 """
176 176 validFilelist = []
177 177 fileList = os.listdir(path)
178 178
179 179 # 0 1234 567 89A BCDE
180 180 # H YYYY DDD SSS .ext
181 181
182 182 for file in fileList:
183 183 try:
184 184 year = int(file[1:5])
185 185 doy = int(file[5:8])
186 186
187 187
188 188 except:
189 189 continue
190 190
191 191 if (os.path.splitext(file)[-1].lower() != ext.lower()):
192 192 continue
193 193
194 194 validFilelist.append(file)
195 195
196 196 if validFilelist:
197 197 validFilelist = sorted( validFilelist, key=str.lower )
198 198 return validFilelist[-1]
199 199
200 200 return None
201 201
202 202 def checkForRealPath(path, foldercounter, year, doy, set, ext):
203 203 """
204 204 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
205 205 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
206 206 el path exacto de un determinado file.
207 207
208 208 Example :
209 209 nombre correcto del file es .../.../D2009307/P2009307367.ext
210 210
211 211 Entonces la funcion prueba con las siguientes combinaciones
212 212 .../.../y2009307367.ext
213 213 .../.../Y2009307367.ext
214 214 .../.../x2009307/y2009307367.ext
215 215 .../.../x2009307/Y2009307367.ext
216 216 .../.../X2009307/y2009307367.ext
217 217 .../.../X2009307/Y2009307367.ext
218 218 siendo para este caso, la ultima combinacion de letras, identica al file buscado
219 219
220 220 Return:
221 221 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
222 222 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
223 223 para el filename
224 224 """
225 225 fullfilename = None
226 226 find_flag = False
227 227 filename = None
228 228
229 229 prefixDirList = [None,'d','D']
230 230 if ext.lower() == ".r": #voltage
231 231 prefixFileList = ['d','D']
232 232 elif ext.lower() == ".pdata": #spectra
233 233 prefixFileList = ['p','P']
234 234 else:
235 235 return None, filename
236 236
237 237 #barrido por las combinaciones posibles
238 238 for prefixDir in prefixDirList:
239 239 thispath = path
240 240 if prefixDir != None:
241 241 #formo el nombre del directorio xYYYYDDD (x=d o x=D)
242 242 if foldercounter == 0:
243 243 thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
244 244 else:
245 245 thispath = os.path.join(path, "%s%04d%03d_%02d" % ( prefixDir, year, doy , foldercounter))
246 246 for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"
247 247 filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
248 248 fullfilename = os.path.join( thispath, filename ) #formo el path completo
249 249
250 250 if os.path.exists( fullfilename ): #verifico que exista
251 251 find_flag = True
252 252 break
253 253 if find_flag:
254 254 break
255 255
256 256 if not(find_flag):
257 257 return None, filename
258 258
259 259 return fullfilename, filename
260 260
261 261 def isDoyFolder(folder):
262 262 try:
263 263 year = int(folder[1:5])
264 264 except:
265 265 return 0
266 266
267 267 try:
268 268 doy = int(folder[5:8])
269 269 except:
270 270 return 0
271 271
272 272 return 1
273 273
274 274 class JRODataIO:
275 275
276 276 c = 3E8
277 277
278 278 isConfig = False
279 279
280 280 basicHeaderObj = BasicHeader(LOCALTIME)
281 281
282 282 systemHeaderObj = SystemHeader()
283 283
284 284 radarControllerHeaderObj = RadarControllerHeader()
285 285
286 286 processingHeaderObj = ProcessingHeader()
287 287
288 288 online = 0
289 289
290 290 dtype = None
291 291
292 292 pathList = []
293 293
294 294 filenameList = []
295 295
296 296 filename = None
297 297
298 298 ext = None
299 299
300 300 flagIsNewFile = 1
301 301
302 302 flagTimeBlock = 0
303 303
304 304 flagIsNewBlock = 0
305 305
306 306 fp = None
307 307
308 308 firstHeaderSize = 0
309 309
310 310 basicHeaderSize = 24
311 311
312 312 versionFile = 1103
313 313
314 314 fileSize = None
315 315
316 316 ippSeconds = None
317 317
318 318 fileSizeByHeader = None
319 319
320 320 fileIndex = None
321 321
322 322 profileIndex = None
323 323
324 324 blockIndex = None
325 325
326 326 nTotalBlocks = None
327 327
328 328 maxTimeStep = 30
329 329
330 330 lastUTTime = None
331 331
332 332 datablock = None
333 333
334 334 dataOut = None
335 335
336 336 blocksize = None
337 337
338 338 def __init__(self):
339 339
340 340 raise ValueError, "Not implemented"
341 341
342 342 def run(self):
343 343
344 344 raise ValueError, "Not implemented"
345 345
346 346 def getOutput(self):
347 347
348 348 return self.dataOut
349 349
350 350 class JRODataReader(JRODataIO, ProcessingUnit):
351 351
352 352 nReadBlocks = 0
353 353
354 354 delay = 10 #number of seconds waiting a new file
355 355
356 356 nTries = 3 #quantity tries
357 357
358 358 nFiles = 3 #number of files for searching
359 359
360 360 path = None
361 361
362 362 foldercounter = 0
363 363
364 364 flagNoMoreFiles = 0
365 365
366 366 datetimeList = []
367 367
368 368 __isFirstTimeOnline = 1
369 369
370 370 __printInfo = True
371 371
372 372 profileIndex = None
373 373
374 374 def __init__(self):
375 375
376 376 """
377 377
378 378 """
379 379
380 380 raise ValueError, "This method has not been implemented"
381 381
382 382
383 383 def createObjByDefault(self):
384 384 """
385 385
386 386 """
387 387 raise ValueError, "This method has not been implemented"
388 388
389 389 def getBlockDimension(self):
390 390
391 391 raise ValueError, "No implemented"
392 392
393 393 def __searchFilesOffLine(self,
394 394 path,
395 395 startDate,
396 396 endDate,
397 397 startTime=datetime.time(0,0,0),
398 398 endTime=datetime.time(23,59,59),
399 399 set=None,
400 400 expLabel='',
401 401 ext='.r',
402 402 walk=True):
403 403
404 404 pathList = []
405 405
406 406 if not walk:
407 407 #pathList.append(path)
408 408 multi_path = path.split(',')
409 409 for single_path in multi_path:
410 410 pathList.append(single_path)
411 411
412 412 else:
413 413 #dirList = []
414 414 multi_path = path.split(',')
415 415 for single_path in multi_path:
416 416 dirList = []
417 417 for thisPath in os.listdir(single_path):
418 418 if not os.path.isdir(os.path.join(single_path,thisPath)):
419 419 continue
420 420 if not isDoyFolder(thisPath):
421 421 continue
422 422
423 423 dirList.append(thisPath)
424 424
425 425 if not(dirList):
426 426 return None, None
427 427
428 428 thisDate = startDate
429 429
430 430 while(thisDate <= endDate):
431 431 year = thisDate.timetuple().tm_year
432 432 doy = thisDate.timetuple().tm_yday
433 433
434 434 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
435 435 if len(matchlist) == 0:
436 436 thisDate += datetime.timedelta(1)
437 437 continue
438 438 for match in matchlist:
439 439 pathList.append(os.path.join(single_path,match,expLabel))
440 440
441 441 thisDate += datetime.timedelta(1)
442 442
443 443 if pathList == []:
444 444 print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
445 445 return None, None
446 446
447 447 print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
448 448
449 449 filenameList = []
450 450 datetimeList = []
451 451 pathDict = {}
452 452 filenameList_to_sort = []
453 453
454 454 for i in range(len(pathList)):
455 455
456 456 thisPath = pathList[i]
457 457
458 458 fileList = glob.glob1(thisPath, "*%s" %ext)
459 459 fileList.sort()
460 460 pathDict.setdefault(fileList[0])
461 461 pathDict[fileList[0]] = i
462 462 filenameList_to_sort.append(fileList[0])
463 463
464 464 filenameList_to_sort.sort()
465 465
466 466 for file in filenameList_to_sort:
467 467 thisPath = pathList[pathDict[file]]
468 468
469 469 fileList = glob.glob1(thisPath, "*%s" %ext)
470 470 fileList.sort()
471 471
472 472 for file in fileList:
473 473
474 474 filename = os.path.join(thisPath,file)
475 475 thisDatetime = isFileinThisTime(filename, startTime, endTime)
476 476
477 477 if not(thisDatetime):
478 478 continue
479 479
480 480 filenameList.append(filename)
481 481 datetimeList.append(thisDatetime)
482 482
483 483 if not(filenameList):
484 484 print "Any file was found for the time range %s - %s" %(startTime, endTime)
485 485 return None, None
486 486
487 487 print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
488 488 print
489 489
490 490 for i in range(len(filenameList)):
491 491 print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
492 492
493 493 self.filenameList = filenameList
494 494 self.datetimeList = datetimeList
495 495
496 496 return pathList, filenameList
497 497
498 498 def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True, set=None):
499 499
500 500 """
501 501 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
502 502 devuelve el archivo encontrado ademas de otros datos.
503 503
504 504 Input:
505 505 path : carpeta donde estan contenidos los files que contiene data
506 506
507 507 expLabel : Nombre del subexperimento (subfolder)
508 508
509 509 ext : extension de los files
510 510
511 511 walk : Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
512 512
513 513 Return:
514 514 directory : eL directorio donde esta el file encontrado
515 515 filename : el ultimo file de una determinada carpeta
516 516 year : el anho
517 517 doy : el numero de dia del anho
518 518 set : el set del archivo
519 519
520 520
521 521 """
522 522 dirList = []
523 523
524 524 if not walk:
525 525 fullpath = path
526 526 foldercounter = 0
527 527 else:
528 528 #Filtra solo los directorios
529 529 for thisPath in os.listdir(path):
530 530 if not os.path.isdir(os.path.join(path,thisPath)):
531 531 continue
532 532 if not isDoyFolder(thisPath):
533 533 continue
534 534
535 535 dirList.append(thisPath)
536 536
537 537 if not(dirList):
538 538 return None, None, None, None, None, None
539 539
540 540 dirList = sorted( dirList, key=str.lower )
541 541
542 542 doypath = dirList[-1]
543 543 foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0
544 544 fullpath = os.path.join(path, doypath, expLabel)
545 545
546 546
547 547 print "%s folder was found: " %(fullpath )
548 548
549 549 if set == None:
550 550 filename = getlastFileFromPath(fullpath, ext)
551 551 else:
552 552 filename = getFileFromSet(fullpath, ext, set)
553 553
554 554 if not(filename):
555 555 return None, None, None, None, None, None
556 556
557 557 print "%s file was found" %(filename)
558 558
559 559 if not(self.__verifyFile(os.path.join(fullpath, filename))):
560 560 return None, None, None, None, None, None
561 561
562 562 year = int( filename[1:5] )
563 563 doy = int( filename[5:8] )
564 564 set = int( filename[8:11] )
565 565
566 566 return fullpath, foldercounter, filename, year, doy, set
567 567
568 568 def __setNextFileOffline(self):
569 569
570 570 idFile = self.fileIndex
571 571
572 572 while (True):
573 573 idFile += 1
574 574 if not(idFile < len(self.filenameList)):
575 575 self.flagNoMoreFiles = 1
576 576 print "No more Files"
577 577 return 0
578 578
579 579 filename = self.filenameList[idFile]
580 580
581 581 if not(self.__verifyFile(filename)):
582 582 continue
583 583
584 584 fileSize = os.path.getsize(filename)
585 585 fp = open(filename,'rb')
586 586 break
587 587
588 588 self.flagIsNewFile = 1
589 589 self.fileIndex = idFile
590 590 self.filename = filename
591 591 self.fileSize = fileSize
592 592 self.fp = fp
593 593
594 594 print "Setting the file: %s"%self.filename
595 595
596 596 return 1
597 597
598 598 def __setNextFileOnline(self):
599 599 """
600 600 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
601 601 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
602 602 siguientes.
603 603
604 604 Affected:
605 605 self.flagIsNewFile
606 606 self.filename
607 607 self.fileSize
608 608 self.fp
609 609 self.set
610 610 self.flagNoMoreFiles
611 611
612 612 Return:
613 613 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
614 614 1 : si el file fue abierto con exito y esta listo a ser leido
615 615
616 616 Excepciones:
617 617 Si un determinado file no puede ser abierto
618 618 """
619 619 nFiles = 0
620 620 fileOk_flag = False
621 621 firstTime_flag = True
622 622
623 623 self.set += 1
624 624
625 625 if self.set > 999:
626 626 self.set = 0
627 627 self.foldercounter += 1
628 628
629 629 #busca el 1er file disponible
630 630 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
631 631 if fullfilename:
632 632 if self.__verifyFile(fullfilename, False):
633 633 fileOk_flag = True
634 634
635 635 #si no encuentra un file entonces espera y vuelve a buscar
636 636 if not(fileOk_flag):
637 637 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
638 638
639 639 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
640 640 tries = self.nTries
641 641 else:
642 642 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
643 643
644 644 for nTries in range( tries ):
645 645 if firstTime_flag:
646 646 print "\tWaiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
647 647 time.sleep( self.delay )
648 648 else:
649 649 print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
650 650
651 651 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
652 652 if fullfilename:
653 653 if self.__verifyFile(fullfilename):
654 654 fileOk_flag = True
655 655 break
656 656
657 657 if fileOk_flag:
658 658 break
659 659
660 660 firstTime_flag = False
661 661
662 662 print "\tSkipping the file \"%s\" due to this file doesn't exist" % filename
663 663 self.set += 1
664 664
665 665 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
666 666 self.set = 0
667 667 self.doy += 1
668 668 self.foldercounter = 0
669 669
670 670 if fileOk_flag:
671 671 self.fileSize = os.path.getsize( fullfilename )
672 672 self.filename = fullfilename
673 673 self.flagIsNewFile = 1
674 674 if self.fp != None: self.fp.close()
675 675 self.fp = open(fullfilename, 'rb')
676 676 self.flagNoMoreFiles = 0
677 677 print 'Setting the file: %s' % fullfilename
678 678 else:
679 679 self.fileSize = 0
680 680 self.filename = None
681 681 self.flagIsNewFile = 0
682 682 self.fp = None
683 683 self.flagNoMoreFiles = 1
684 684 print 'No more Files'
685 685
686 686 return fileOk_flag
687 687
688 688
689 689 def setNextFile(self):
690 690 if self.fp != None:
691 691 self.fp.close()
692 692
693 693 if self.online:
694 694 newFile = self.__setNextFileOnline()
695 695 else:
696 696 newFile = self.__setNextFileOffline()
697 697
698 698 if not(newFile):
699 699 return 0
700 700
701 701 self.__readFirstHeader()
702 702 self.nReadBlocks = 0
703 703 return 1
704 704
705 705 def __waitNewBlock(self):
706 706 """
707 707 Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
708 708
709 709 Si el modo de lectura es OffLine siempre retorn 0
710 710 """
711 711 if not self.online:
712 712 return 0
713 713
714 714 if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
715 715 return 0
716 716
717 717 currentPointer = self.fp.tell()
718 718
719 719 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
720 720
721 721 for nTries in range( self.nTries ):
722 722
723 723 self.fp.close()
724 724 self.fp = open( self.filename, 'rb' )
725 725 self.fp.seek( currentPointer )
726 726
727 727 self.fileSize = os.path.getsize( self.filename )
728 728 currentSize = self.fileSize - currentPointer
729 729
730 730 if ( currentSize >= neededSize ):
731 731 self.__rdBasicHeader()
732 732 return 1
733 733
734 734 if self.fileSize == self.fileSizeByHeader:
735 735 # self.flagEoF = True
736 736 return 0
737 737
738 738 print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
739 739 time.sleep( self.delay )
740 740
741 741
742 742 return 0
743 743
744 744 def waitDataBlock(self,pointer_location):
745 745
746 746 currentPointer = pointer_location
747 747
748 748 neededSize = self.processingHeaderObj.blockSize #+ self.basicHeaderSize
749 749
750 750 for nTries in range( self.nTries ):
751 751 self.fp.close()
752 752 self.fp = open( self.filename, 'rb' )
753 753 self.fp.seek( currentPointer )
754 754
755 755 self.fileSize = os.path.getsize( self.filename )
756 756 currentSize = self.fileSize - currentPointer
757 757
758 758 if ( currentSize >= neededSize ):
759 759 return 1
760 760
761 761 print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
762 762 time.sleep( self.delay )
763 763
764 764 return 0
765 765
766 766
767 767 def __jumpToLastBlock(self):
768 768
769 769 if not(self.__isFirstTimeOnline):
770 770 return
771 771
772 772 csize = self.fileSize - self.fp.tell()
773 773 blocksize = self.processingHeaderObj.blockSize
774 774
775 775 #salta el primer bloque de datos
776 776 if csize > self.processingHeaderObj.blockSize:
777 777 self.fp.seek(self.fp.tell() + blocksize)
778 778 else:
779 779 return
780 780
781 781 csize = self.fileSize - self.fp.tell()
782 782 neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
783 783 while True:
784 784
785 785 if self.fp.tell()<self.fileSize:
786 786 self.fp.seek(self.fp.tell() + neededsize)
787 787 else:
788 788 self.fp.seek(self.fp.tell() - neededsize)
789 789 break
790 790
791 791 # csize = self.fileSize - self.fp.tell()
792 792 # neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
793 793 # factor = int(csize/neededsize)
794 794 # if factor > 0:
795 795 # self.fp.seek(self.fp.tell() + factor*neededsize)
796 796
797 797 self.flagIsNewFile = 0
798 798 self.__isFirstTimeOnline = 0
799 799
800 800
801 801 def __setNewBlock(self):
802 802
803 803 if self.fp == None:
804 804 return 0
805 805
806 806 if self.online:
807 807 self.__jumpToLastBlock()
808 808
809 809 if self.flagIsNewFile:
810 810 return 1
811 811
812 812 self.lastUTTime = self.basicHeaderObj.utc
813 813 currentSize = self.fileSize - self.fp.tell()
814 814 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
815 815
816 816 if (currentSize >= neededSize):
817 817 self.__rdBasicHeader()
818 818 return 1
819 819
820 820 if self.__waitNewBlock():
821 821 return 1
822 822
823 823 if not(self.setNextFile()):
824 824 return 0
825 825
826 826 deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
827 827
828 828 self.flagTimeBlock = 0
829 829
830 830 if deltaTime > self.maxTimeStep:
831 831 self.flagTimeBlock = 1
832 832
833 833 return 1
834 834
835 835
836 836 def readNextBlock(self):
837 837 if not(self.__setNewBlock()):
838 838 return 0
839 839
840 840 if not(self.readBlock()):
841 841 return 0
842 842
843 843 return 1
844 844
845 845 def __rdProcessingHeader(self, fp=None):
846 846 if fp == None:
847 847 fp = self.fp
848 848
849 849 self.processingHeaderObj.read(fp)
850 850
851 851 def __rdRadarControllerHeader(self, fp=None):
852 852 if fp == None:
853 853 fp = self.fp
854 854
855 855 self.radarControllerHeaderObj.read(fp)
856 856
857 857 def __rdSystemHeader(self, fp=None):
858 858 if fp == None:
859 859 fp = self.fp
860 860
861 861 self.systemHeaderObj.read(fp)
862 862
863 863 def __rdBasicHeader(self, fp=None):
864 864 if fp == None:
865 865 fp = self.fp
866 866
867 867 self.basicHeaderObj.read(fp)
868 868
869 869
870 870 def __readFirstHeader(self):
871 871 self.__rdBasicHeader()
872 872 self.__rdSystemHeader()
873 873 self.__rdRadarControllerHeader()
874 874 self.__rdProcessingHeader()
875 875
876 876 self.firstHeaderSize = self.basicHeaderObj.size
877 877
878 878 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
879 879 if datatype == 0:
880 880 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
881 881 elif datatype == 1:
882 882 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
883 883 elif datatype == 2:
884 884 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
885 885 elif datatype == 3:
886 886 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
887 887 elif datatype == 4:
888 888 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
889 889 elif datatype == 5:
890 890 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
891 891 else:
892 892 raise ValueError, 'Data type was not defined'
893 893
894 894 self.dtype = datatype_str
895 895 self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
896 896 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
897 897 # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
898 898 # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
899 899 self.getBlockDimension()
900 900
901 901
902 902 def __verifyFile(self, filename, msgFlag=True):
903 903 msg = None
904 904 try:
905 905 fp = open(filename, 'rb')
906 906 currentPosition = fp.tell()
907 907 except:
908 908 if msgFlag:
909 909 print "The file %s can't be opened" % (filename)
910 910 return False
911 911
912 912 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
913 913
914 914 if neededSize == 0:
915 915 basicHeaderObj = BasicHeader(LOCALTIME)
916 916 systemHeaderObj = SystemHeader()
917 917 radarControllerHeaderObj = RadarControllerHeader()
918 918 processingHeaderObj = ProcessingHeader()
919 919
920 920 try:
921 921 if not( basicHeaderObj.read(fp) ): raise IOError
922 922 if not( systemHeaderObj.read(fp) ): raise IOError
923 923 if not( radarControllerHeaderObj.read(fp) ): raise IOError
924 924 if not( processingHeaderObj.read(fp) ): raise IOError
925 925 data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
926 926
927 927 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
928 928
929 929 except:
930 930 if msgFlag:
931 931 print "\tThe file %s is empty or it hasn't enough data" % filename
932 932
933 933 fp.close()
934 934 return False
935 935 else:
936 936 msg = "\tSkipping the file %s due to it hasn't enough data" %filename
937 937
938 938 fp.close()
939 939 fileSize = os.path.getsize(filename)
940 940 currentSize = fileSize - currentPosition
941 941 if currentSize < neededSize:
942 942 if msgFlag and (msg != None):
943 943 print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
944 944 return False
945 945
946 946 return True
947 947
948 948 def setup(self,
949 949 path=None,
950 950 startDate=None,
951 951 endDate=None,
952 952 startTime=datetime.time(0,0,0),
953 953 endTime=datetime.time(23,59,59),
954 954 set=None,
955 955 expLabel = "",
956 956 ext = None,
957 957 online = False,
958 958 delay = 60,
959 959 walk = True):
960 960
961 961 if path == None:
962 962 raise ValueError, "The path is not valid"
963 963
964 964 if ext == None:
965 965 ext = self.ext
966 966
967 967 if online:
968 968 print "Searching files in online mode..."
969 969
970 970 for nTries in range( self.nTries ):
971 971 fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk, set=set)
972 972
973 973 if fullpath:
974 974 break
975 975
976 976 print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
977 977 time.sleep( self.delay )
978 978
979 979 if not(fullpath):
980 980 print "There 'isn't valied files in %s" % path
981 981 return None
982 982
983 983 self.year = year
984 984 self.doy = doy
985 985 self.set = set - 1
986 986 self.path = path
987 987 self.foldercounter = foldercounter
988 last_set = None
988 989
989 990 else:
990 991 print "Searching files in offline mode ..."
991 992 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
992 993 startTime=startTime, endTime=endTime,
993 994 set=set, expLabel=expLabel, ext=ext,
994 995 walk=walk)
995 996
996 997 if not(pathList):
997 998 print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
998 999 datetime.datetime.combine(startDate,startTime).ctime(),
999 1000 datetime.datetime.combine(endDate,endTime).ctime())
1000 1001
1001 1002 sys.exit(-1)
1002 1003
1003 1004
1004 1005 self.fileIndex = -1
1005 1006 self.pathList = pathList
1006 1007 self.filenameList = filenameList
1008 file_name = os.path.basename(filenameList[-1])
1009 basename, ext = os.path.splitext(file_name)
1010 last_set = int(basename[-3:])
1007 1011
1008 1012 self.online = online
1009 1013 self.delay = delay
1010 1014 ext = ext.lower()
1011 1015 self.ext = ext
1012 1016
1013 1017 if not(self.setNextFile()):
1014 1018 if (startDate!=None) and (endDate!=None):
1015 1019 print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
1016 1020 elif startDate != None:
1017 1021 print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
1018 1022 else:
1019 1023 print "No files"
1020 1024
1021 1025 sys.exit(-1)
1022 1026
1023 1027 # self.updateDataHeader()
1024
1028 if last_set != None:
1029 self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
1025 1030 return self.dataOut
1026 1031
1027 1032 def getBasicHeader(self):
1028 1033
1029 1034 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
1030 1035
1031 1036 self.dataOut.flagTimeBlock = self.flagTimeBlock
1032 1037
1033 1038 self.dataOut.timeZone = self.basicHeaderObj.timeZone
1034 1039
1035 1040 self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
1036 1041
1037 1042 self.dataOut.errorCount = self.basicHeaderObj.errorCount
1038 1043
1039 1044 self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
1040 1045
1041 1046 def getFirstHeader(self):
1042 1047
1043 1048 raise ValueError, "This method has not been implemented"
1044 1049
1045 1050 def getData():
1046 1051
1047 1052 raise ValueError, "This method has not been implemented"
1048 1053
1049 1054 def hasNotDataInBuffer():
1050 1055
1051 1056 raise ValueError, "This method has not been implemented"
1052 1057
1053 1058 def readBlock():
1054 1059
1055 1060 raise ValueError, "This method has not been implemented"
1056 1061
1057 1062 def isEndProcess(self):
1058 1063
1059 1064 return self.flagNoMoreFiles
1060 1065
1061 1066 def printReadBlocks(self):
1062 1067
1063 1068 print "Number of read blocks per file %04d" %self.nReadBlocks
1064 1069
1065 1070 def printTotalBlocks(self):
1066 1071
1067 1072 print "Number of read blocks %04d" %self.nTotalBlocks
1068 1073
1069 1074 def printNumberOfBlock(self):
1070 1075
1071 1076 if self.flagIsNewBlock:
1072 1077 print "Block No. %04d, Total blocks %04d -> %s" %(self.basicHeaderObj.dataBlock, self.nTotalBlocks, self.dataOut.datatime.ctime())
1073
1078 self.dataOut.blocknow = self.basicHeaderObj.dataBlock
1074 1079 def printInfo(self):
1075 1080
1076 1081 if self.__printInfo == False:
1077 1082 return
1078 1083
1079 1084 self.basicHeaderObj.printInfo()
1080 1085 self.systemHeaderObj.printInfo()
1081 1086 self.radarControllerHeaderObj.printInfo()
1082 1087 self.processingHeaderObj.printInfo()
1083 1088
1084 1089 self.__printInfo = False
1085 1090
1086 1091
1087 1092 def run(self, **kwargs):
1088 1093
1089 1094 if not(self.isConfig):
1090 1095
1091 1096 # self.dataOut = dataOut
1092 1097 self.setup(**kwargs)
1093 1098 self.isConfig = True
1094 1099
1095 1100 self.getData()
1096 1101
1097 1102 class JRODataWriter(JRODataIO, Operation):
1098 1103
1099 1104 """
1100 1105 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
1101 1106 de los datos siempre se realiza por bloques.
1102 1107 """
1103 1108
1104 1109 blockIndex = 0
1105 1110
1106 1111 path = None
1107 1112
1108 1113 setFile = None
1109 1114
1110 1115 profilesPerBlock = None
1111 1116
1112 1117 blocksPerFile = None
1113 1118
1114 1119 nWriteBlocks = 0
1115 1120
1116 1121 def __init__(self, dataOut=None):
1117 1122 raise ValueError, "Not implemented"
1118 1123
1119 1124
1120 1125 def hasAllDataInBuffer(self):
1121 1126 raise ValueError, "Not implemented"
1122 1127
1123 1128
1124 1129 def setBlockDimension(self):
1125 1130 raise ValueError, "Not implemented"
1126 1131
1127 1132
1128 1133 def writeBlock(self):
1129 1134 raise ValueError, "No implemented"
1130 1135
1131 1136
1132 1137 def putData(self):
1133 1138 raise ValueError, "No implemented"
1134 1139
1135 1140
1136 1141 def setBasicHeader(self):
1137 1142
1138 1143 self.basicHeaderObj.size = self.basicHeaderSize #bytes
1139 1144 self.basicHeaderObj.version = self.versionFile
1140 1145 self.basicHeaderObj.dataBlock = self.nTotalBlocks
1141 1146
1142 1147 utc = numpy.floor(self.dataOut.utctime)
1143 1148 milisecond = (self.dataOut.utctime - utc)* 1000.0
1144 1149
1145 1150 self.basicHeaderObj.utc = utc
1146 1151 self.basicHeaderObj.miliSecond = milisecond
1147 1152 self.basicHeaderObj.timeZone = self.dataOut.timeZone
1148 1153 self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
1149 1154 self.basicHeaderObj.errorCount = self.dataOut.errorCount
1150 1155
1151 1156 def setFirstHeader(self):
1152 1157 """
1153 1158 Obtiene una copia del First Header
1154 1159
1155 1160 Affected:
1156 1161
1157 1162 self.basicHeaderObj
1158 1163 self.systemHeaderObj
1159 1164 self.radarControllerHeaderObj
1160 1165 self.processingHeaderObj self.
1161 1166
1162 1167 Return:
1163 1168 None
1164 1169 """
1165 1170
1166 1171 raise ValueError, "No implemented"
1167 1172
1168 1173 def __writeFirstHeader(self):
1169 1174 """
1170 1175 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1171 1176
1172 1177 Affected:
1173 1178 __dataType
1174 1179
1175 1180 Return:
1176 1181 None
1177 1182 """
1178 1183
1179 1184 # CALCULAR PARAMETROS
1180 1185
1181 1186 sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
1182 1187 self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
1183 1188
1184 1189 self.basicHeaderObj.write(self.fp)
1185 1190 self.systemHeaderObj.write(self.fp)
1186 1191 self.radarControllerHeaderObj.write(self.fp)
1187 1192 self.processingHeaderObj.write(self.fp)
1188 1193
1189 1194 self.dtype = self.dataOut.dtype
1190 1195
1191 1196 def __setNewBlock(self):
1192 1197 """
1193 1198 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1194 1199
1195 1200 Return:
1196 1201 0 : si no pudo escribir nada
1197 1202 1 : Si escribio el Basic el First Header
1198 1203 """
1199 1204 if self.fp == None:
1200 1205 self.setNextFile()
1201 1206
1202 1207 if self.flagIsNewFile:
1203 1208 return 1
1204 1209
1205 1210 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
1206 1211 self.basicHeaderObj.write(self.fp)
1207 1212 return 1
1208 1213
1209 1214 if not( self.setNextFile() ):
1210 1215 return 0
1211 1216
1212 1217 return 1
1213 1218
1214 1219
1215 1220 def writeNextBlock(self):
1216 1221 """
1217 1222 Selecciona el bloque siguiente de datos y los escribe en un file
1218 1223
1219 1224 Return:
1220 1225 0 : Si no hizo pudo escribir el bloque de datos
1221 1226 1 : Si no pudo escribir el bloque de datos
1222 1227 """
1223 1228 if not( self.__setNewBlock() ):
1224 1229 return 0
1225 1230
1226 1231 self.writeBlock()
1227 1232
1228 1233 return 1
1229 1234
1230 1235 def setNextFile(self):
1231 1236 """
1232 1237 Determina el siguiente file que sera escrito
1233 1238
1234 1239 Affected:
1235 1240 self.filename
1236 1241 self.subfolder
1237 1242 self.fp
1238 1243 self.setFile
1239 1244 self.flagIsNewFile
1240 1245
1241 1246 Return:
1242 1247 0 : Si el archivo no puede ser escrito
1243 1248 1 : Si el archivo esta listo para ser escrito
1244 1249 """
1245 1250 ext = self.ext
1246 1251 path = self.path
1247 1252
1248 1253 if self.fp != None:
1249 1254 self.fp.close()
1250 1255
1251 1256 timeTuple = time.localtime( self.dataOut.utctime)
1252 1257 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1253 1258
1254 1259 fullpath = os.path.join( path, subfolder )
1255 1260 if not( os.path.exists(fullpath) ):
1256 1261 os.mkdir(fullpath)
1257 1262 self.setFile = -1 #inicializo mi contador de seteo
1258 1263 else:
1259 1264 filesList = os.listdir( fullpath )
1260 1265 if len( filesList ) > 0:
1261 1266 filesList = sorted( filesList, key=str.lower )
1262 1267 filen = filesList[-1]
1263 1268 # el filename debera tener el siguiente formato
1264 1269 # 0 1234 567 89A BCDE (hex)
1265 1270 # x YYYY DDD SSS .ext
1266 1271 if isNumber( filen[8:11] ):
1267 1272 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1268 1273 else:
1269 1274 self.setFile = -1
1270 1275 else:
1271 1276 self.setFile = -1 #inicializo mi contador de seteo
1272 1277
1273 1278 setFile = self.setFile
1274 1279 setFile += 1
1275 1280
1276 1281 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
1277 1282 timeTuple.tm_year,
1278 1283 timeTuple.tm_yday,
1279 1284 setFile,
1280 1285 ext )
1281 1286
1282 1287 filename = os.path.join( path, subfolder, file )
1283 1288
1284 1289 fp = open( filename,'wb' )
1285 1290
1286 1291 self.blockIndex = 0
1287 1292
1288 1293 #guardando atributos
1289 1294 self.filename = filename
1290 1295 self.subfolder = subfolder
1291 1296 self.fp = fp
1292 1297 self.setFile = setFile
1293 1298 self.flagIsNewFile = 1
1294 1299
1295 1300 self.setFirstHeader()
1296 1301
1297 1302 print 'Writing the file: %s'%self.filename
1298 1303
1299 1304 self.__writeFirstHeader()
1300 1305
1301 1306 return 1
1302 1307
1303 1308 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=0, ext=None):
1304 1309 """
1305 1310 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1306 1311
1307 1312 Inputs:
1308 1313 path : el path destino en el cual se escribiran los files a crear
1309 1314 format : formato en el cual sera salvado un file
1310 1315 set : el setebo del file
1311 1316
1312 1317 Return:
1313 1318 0 : Si no realizo un buen seteo
1314 1319 1 : Si realizo un buen seteo
1315 1320 """
1316 1321
1317 1322 if ext == None:
1318 1323 ext = self.ext
1319 1324
1320 1325 ext = ext.lower()
1321 1326
1322 1327 self.ext = ext
1323 1328
1324 1329 self.path = path
1325 1330
1326 1331 self.setFile = set - 1
1327 1332
1328 1333 self.blocksPerFile = blocksPerFile
1329 1334
1330 1335 self.profilesPerBlock = profilesPerBlock
1331 1336
1332 1337 self.dataOut = dataOut
1333 1338
1334 1339 if not(self.setNextFile()):
1335 1340 print "There isn't a next file"
1336 1341 return 0
1337 1342
1338 1343 self.setBlockDimension()
1339 1344
1340 1345 return 1
1341 1346
1342 1347 def run(self, dataOut, **kwargs):
1343 1348
1344 1349 if not(self.isConfig):
1345 1350
1346 1351 self.setup(dataOut, **kwargs)
1347 1352 self.isConfig = True
1348 1353
1349 1354 self.putData()
1350 1355
1351 1356 class VoltageReader(JRODataReader):
1352 1357 """
1353 1358 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
1354 1359 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
1355 1360 perfiles*alturas*canales) son almacenados en la variable "buffer".
1356 1361
1357 1362 perfiles * alturas * canales
1358 1363
1359 1364 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
1360 1365 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
1361 1366 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
1362 1367 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
1363 1368
1364 1369 Example:
1365 1370
1366 1371 dpath = "/home/myuser/data"
1367 1372
1368 1373 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
1369 1374
1370 1375 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
1371 1376
1372 1377 readerObj = VoltageReader()
1373 1378
1374 1379 readerObj.setup(dpath, startTime, endTime)
1375 1380
1376 1381 while(True):
1377 1382
1378 1383 #to get one profile
1379 1384 profile = readerObj.getData()
1380 1385
1381 1386 #print the profile
1382 1387 print profile
1383 1388
1384 1389 #If you want to see all datablock
1385 1390 print readerObj.datablock
1386 1391
1387 1392 if readerObj.flagNoMoreFiles:
1388 1393 break
1389 1394
1390 1395 """
1391 1396
1392 1397 ext = ".r"
1393 1398
1394 1399 optchar = "D"
1395 1400 dataOut = None
1396 1401
1397 1402
1398 1403 def __init__(self):
1399 1404 """
1400 1405 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
1401 1406
1402 1407 Input:
1403 1408 dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para
1404 1409 almacenar un perfil de datos cada vez que se haga un requerimiento
1405 1410 (getData). El perfil sera obtenido a partir del buffer de datos,
1406 1411 si el buffer esta vacio se hara un nuevo proceso de lectura de un
1407 1412 bloque de datos.
1408 1413 Si este parametro no es pasado se creara uno internamente.
1409 1414
1410 1415 Variables afectadas:
1411 1416 self.dataOut
1412 1417
1413 1418 Return:
1414 1419 None
1415 1420 """
1416 1421
1417 1422 self.isConfig = False
1418 1423
1419 1424 self.datablock = None
1420 1425
1421 1426 self.utc = 0
1422 1427
1423 1428 self.ext = ".r"
1424 1429
1425 1430 self.optchar = "D"
1426 1431
1427 1432 self.basicHeaderObj = BasicHeader(LOCALTIME)
1428 1433
1429 1434 self.systemHeaderObj = SystemHeader()
1430 1435
1431 1436 self.radarControllerHeaderObj = RadarControllerHeader()
1432 1437
1433 1438 self.processingHeaderObj = ProcessingHeader()
1434 1439
1435 1440 self.online = 0
1436 1441
1437 1442 self.fp = None
1438 1443
1439 1444 self.idFile = None
1440 1445
1441 1446 self.dtype = None
1442 1447
1443 1448 self.fileSizeByHeader = None
1444 1449
1445 1450 self.filenameList = []
1446 1451
1447 1452 self.filename = None
1448 1453
1449 1454 self.fileSize = None
1450 1455
1451 1456 self.firstHeaderSize = 0
1452 1457
1453 1458 self.basicHeaderSize = 24
1454 1459
1455 1460 self.pathList = []
1456 1461
1457 1462 self.filenameList = []
1458 1463
1459 1464 self.lastUTTime = 0
1460 1465
1461 1466 self.maxTimeStep = 30
1462 1467
1463 1468 self.flagNoMoreFiles = 0
1464 1469
1465 1470 self.set = 0
1466 1471
1467 1472 self.path = None
1468 1473
1469 1474 self.profileIndex = 2**32-1
1470 1475
1471 1476 self.delay = 3 #seconds
1472 1477
1473 1478 self.nTries = 3 #quantity tries
1474 1479
1475 1480 self.nFiles = 3 #number of files for searching
1476 1481
1477 1482 self.nReadBlocks = 0
1478 1483
1479 1484 self.flagIsNewFile = 1
1480 1485
1481 1486 self.__isFirstTimeOnline = 1
1482 1487
1483 1488 self.ippSeconds = 0
1484 1489
1485 1490 self.flagTimeBlock = 0
1486 1491
1487 1492 self.flagIsNewBlock = 0
1488 1493
1489 1494 self.nTotalBlocks = 0
1490 1495
1491 1496 self.blocksize = 0
1492 1497
1493 1498 self.dataOut = self.createObjByDefault()
1494 1499
1495 1500 def createObjByDefault(self):
1496 1501
1497 1502 dataObj = Voltage()
1498 1503
1499 1504 return dataObj
1500 1505
1501 1506 def __hasNotDataInBuffer(self):
1502 1507 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
1503 1508 return 1
1504 1509 return 0
1505 1510
1506 1511
1507 1512 def getBlockDimension(self):
1508 1513 """
1509 1514 Obtiene la cantidad de puntos a leer por cada bloque de datos
1510 1515
1511 1516 Affected:
1512 1517 self.blocksize
1513 1518
1514 1519 Return:
1515 1520 None
1516 1521 """
1517 1522 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
1518 1523 self.blocksize = pts2read
1519 1524
1520 1525
1521 1526 def readBlock(self):
1522 1527 """
1523 1528 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
1524 1529 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
1525 1530 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
1526 1531 es seteado a 0
1527 1532
1528 1533 Inputs:
1529 1534 None
1530 1535
1531 1536 Return:
1532 1537 None
1533 1538
1534 1539 Affected:
1535 1540 self.profileIndex
1536 1541 self.datablock
1537 1542 self.flagIsNewFile
1538 1543 self.flagIsNewBlock
1539 1544 self.nTotalBlocks
1540 1545
1541 1546 Exceptions:
1542 1547 Si un bloque leido no es un bloque valido
1543 1548 """
1544 1549 current_pointer_location = self.fp.tell()
1545 1550 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
1546 1551
1547 1552 try:
1548 1553 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
1549 1554 except:
1550 1555 #print "The read block (%3d) has not enough data" %self.nReadBlocks
1551 1556
1552 1557 if self.waitDataBlock(pointer_location=current_pointer_location):
1553 1558 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
1554 1559 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
1555 1560 # return 0
1556 1561
1557 1562 junk = numpy.transpose(junk, (2,0,1))
1558 1563 self.datablock = junk['real'] + junk['imag']*1j
1559 1564
1560 1565 self.profileIndex = 0
1561 1566
1562 1567 self.flagIsNewFile = 0
1563 1568 self.flagIsNewBlock = 1
1564 1569
1565 1570 self.nTotalBlocks += 1
1566 1571 self.nReadBlocks += 1
1567 1572
1568 1573 return 1
1569 1574
1570 1575 def getFirstHeader(self):
1571 1576
1572 1577 self.dataOut.dtype = self.dtype
1573 1578
1574 1579 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
1575 1580
1576 1581 xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
1577 1582
1578 1583 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
1579 1584
1580 1585 self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
1581 1586
1582 1587 self.dataOut.ippSeconds = self.ippSeconds
1583 1588
1584 1589 self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
1585 1590
1586 1591 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
1587 1592
1588 1593 self.dataOut.flagShiftFFT = False
1589 1594
1590 1595 if self.radarControllerHeaderObj.code != None:
1591 1596
1592 1597 self.dataOut.nCode = self.radarControllerHeaderObj.nCode
1593 1598
1594 1599 self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
1595 1600
1596 1601 self.dataOut.code = self.radarControllerHeaderObj.code
1597 1602
1598 1603 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
1599 1604
1600 1605 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
1601 1606
1602 1607 self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada
1603 1608
1604 1609 self.dataOut.flagDeflipData = False #asumo q la data no esta sin flip
1605 1610
1606 1611 self.dataOut.flagShiftFFT = False
1607 1612
1608 1613 def getData(self):
1609 1614 """
1610 1615 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
1611 1616 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1612 1617 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
1613 1618
1614 1619 Ademas incrementa el contador del buffer en 1.
1615 1620
1616 1621 Return:
1617 1622 data : retorna un perfil de voltages (alturas * canales) copiados desde el
1618 1623 buffer. Si no hay mas archivos a leer retorna None.
1619 1624
1620 1625 Variables afectadas:
1621 1626 self.dataOut
1622 1627 self.profileIndex
1623 1628
1624 1629 Affected:
1625 1630 self.dataOut
1626 1631 self.profileIndex
1627 1632 self.flagTimeBlock
1628 1633 self.flagIsNewBlock
1629 1634 """
1630 1635
1631 1636 if self.flagNoMoreFiles:
1632 1637 self.dataOut.flagNoData = True
1633 1638 print 'Process finished'
1634 1639 return 0
1635 1640
1636 1641 self.flagTimeBlock = 0
1637 1642 self.flagIsNewBlock = 0
1638 1643
1639 1644 if self.__hasNotDataInBuffer():
1640 1645
1641 1646 if not( self.readNextBlock() ):
1642 1647 return 0
1643 1648
1644 1649 self.getFirstHeader()
1645 1650
1646 1651 if self.datablock == None:
1647 1652 self.dataOut.flagNoData = True
1648 1653 return 0
1649 1654
1650 1655 self.dataOut.data = self.datablock[:,self.profileIndex,:]
1651 1656
1652 1657 self.dataOut.flagNoData = False
1653 1658
1654 1659 self.getBasicHeader()
1655 1660
1656 1661 self.profileIndex += 1
1657 1662
1658 1663 self.dataOut.realtime = self.online
1659 1664
1660 1665 return self.dataOut.data
1661 1666
1662 1667
1663 1668 class VoltageWriter(JRODataWriter):
1664 1669 """
1665 1670 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
1666 1671 de los datos siempre se realiza por bloques.
1667 1672 """
1668 1673
1669 1674 ext = ".r"
1670 1675
1671 1676 optchar = "D"
1672 1677
1673 1678 shapeBuffer = None
1674 1679
1675 1680
1676 1681 def __init__(self):
1677 1682 """
1678 1683 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
1679 1684
1680 1685 Affected:
1681 1686 self.dataOut
1682 1687
1683 1688 Return: None
1684 1689 """
1685 1690
1686 1691 self.nTotalBlocks = 0
1687 1692
1688 1693 self.profileIndex = 0
1689 1694
1690 1695 self.isConfig = False
1691 1696
1692 1697 self.fp = None
1693 1698
1694 1699 self.flagIsNewFile = 1
1695 1700
1696 1701 self.nTotalBlocks = 0
1697 1702
1698 1703 self.flagIsNewBlock = 0
1699 1704
1700 1705 self.setFile = None
1701 1706
1702 1707 self.dtype = None
1703 1708
1704 1709 self.path = None
1705 1710
1706 1711 self.filename = None
1707 1712
1708 1713 self.basicHeaderObj = BasicHeader(LOCALTIME)
1709 1714
1710 1715 self.systemHeaderObj = SystemHeader()
1711 1716
1712 1717 self.radarControllerHeaderObj = RadarControllerHeader()
1713 1718
1714 1719 self.processingHeaderObj = ProcessingHeader()
1715 1720
1716 1721 def hasAllDataInBuffer(self):
1717 1722 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
1718 1723 return 1
1719 1724 return 0
1720 1725
1721 1726
1722 1727 def setBlockDimension(self):
1723 1728 """
1724 1729 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
1725 1730
1726 1731 Affected:
1727 1732 self.shape_spc_Buffer
1728 1733 self.shape_cspc_Buffer
1729 1734 self.shape_dc_Buffer
1730 1735
1731 1736 Return: None
1732 1737 """
1733 1738 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
1734 1739 self.processingHeaderObj.nHeights,
1735 1740 self.systemHeaderObj.nChannels)
1736 1741
1737 1742 self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
1738 1743 self.processingHeaderObj.profilesPerBlock,
1739 1744 self.processingHeaderObj.nHeights),
1740 1745 dtype=numpy.dtype('complex64'))
1741 1746
1742 1747
1743 1748 def writeBlock(self):
1744 1749 """
1745 1750 Escribe el buffer en el file designado
1746 1751
1747 1752 Affected:
1748 1753 self.profileIndex
1749 1754 self.flagIsNewFile
1750 1755 self.flagIsNewBlock
1751 1756 self.nTotalBlocks
1752 1757 self.blockIndex
1753 1758
1754 1759 Return: None
1755 1760 """
1756 1761 data = numpy.zeros( self.shapeBuffer, self.dtype )
1757 1762
1758 1763 junk = numpy.transpose(self.datablock, (1,2,0))
1759 1764
1760 1765 data['real'] = junk.real
1761 1766 data['imag'] = junk.imag
1762 1767
1763 1768 data = data.reshape( (-1) )
1764 1769
1765 1770 data.tofile( self.fp )
1766 1771
1767 1772 self.datablock.fill(0)
1768 1773
1769 1774 self.profileIndex = 0
1770 1775 self.flagIsNewFile = 0
1771 1776 self.flagIsNewBlock = 1
1772 1777
1773 1778 self.blockIndex += 1
1774 1779 self.nTotalBlocks += 1
1775 1780
1776 1781 def putData(self):
1777 1782 """
1778 1783 Setea un bloque de datos y luego los escribe en un file
1779 1784
1780 1785 Affected:
1781 1786 self.flagIsNewBlock
1782 1787 self.profileIndex
1783 1788
1784 1789 Return:
1785 1790 0 : Si no hay data o no hay mas files que puedan escribirse
1786 1791 1 : Si se escribio la data de un bloque en un file
1787 1792 """
1788 1793 if self.dataOut.flagNoData:
1789 1794 return 0
1790 1795
1791 1796 self.flagIsNewBlock = 0
1792 1797
1793 1798 if self.dataOut.flagTimeBlock:
1794 1799
1795 1800 self.datablock.fill(0)
1796 1801 self.profileIndex = 0
1797 1802 self.setNextFile()
1798 1803
1799 1804 if self.profileIndex == 0:
1800 1805 self.setBasicHeader()
1801 1806
1802 1807 self.datablock[:,self.profileIndex,:] = self.dataOut.data
1803 1808
1804 1809 self.profileIndex += 1
1805 1810
1806 1811 if self.hasAllDataInBuffer():
1807 1812 #if self.flagIsNewFile:
1808 1813 self.writeNextBlock()
1809 1814 # self.setFirstHeader()
1810 1815
1811 1816 return 1
1812 1817
1813 1818 def __getProcessFlags(self):
1814 1819
1815 1820 processFlags = 0
1816 1821
1817 1822 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
1818 1823 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
1819 1824 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
1820 1825 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
1821 1826 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
1822 1827 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
1823 1828
1824 1829 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
1825 1830
1826 1831
1827 1832
1828 1833 datatypeValueList = [PROCFLAG.DATATYPE_CHAR,
1829 1834 PROCFLAG.DATATYPE_SHORT,
1830 1835 PROCFLAG.DATATYPE_LONG,
1831 1836 PROCFLAG.DATATYPE_INT64,
1832 1837 PROCFLAG.DATATYPE_FLOAT,
1833 1838 PROCFLAG.DATATYPE_DOUBLE]
1834 1839
1835 1840
1836 1841 for index in range(len(dtypeList)):
1837 1842 if self.dataOut.dtype == dtypeList[index]:
1838 1843 dtypeValue = datatypeValueList[index]
1839 1844 break
1840 1845
1841 1846 processFlags += dtypeValue
1842 1847
1843 1848 if self.dataOut.flagDecodeData:
1844 1849 processFlags += PROCFLAG.DECODE_DATA
1845 1850
1846 1851 if self.dataOut.flagDeflipData:
1847 1852 processFlags += PROCFLAG.DEFLIP_DATA
1848 1853
1849 1854 if self.dataOut.code != None:
1850 1855 processFlags += PROCFLAG.DEFINE_PROCESS_CODE
1851 1856
1852 1857 if self.dataOut.nCohInt > 1:
1853 1858 processFlags += PROCFLAG.COHERENT_INTEGRATION
1854 1859
1855 1860 return processFlags
1856 1861
1857 1862
1858 1863 def __getBlockSize(self):
1859 1864 '''
1860 1865 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
1861 1866 '''
1862 1867
1863 1868 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
1864 1869 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
1865 1870 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
1866 1871 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
1867 1872 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
1868 1873 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
1869 1874
1870 1875 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
1871 1876 datatypeValueList = [1,2,4,8,4,8]
1872 1877 for index in range(len(dtypeList)):
1873 1878 if self.dataOut.dtype == dtypeList[index]:
1874 1879 datatypeValue = datatypeValueList[index]
1875 1880 break
1876 1881
1877 1882 blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.profilesPerBlock * datatypeValue * 2)
1878 1883
1879 1884 return blocksize
1880 1885
1881 1886 def setFirstHeader(self):
1882 1887
1883 1888 """
1884 1889 Obtiene una copia del First Header
1885 1890
1886 1891 Affected:
1887 1892 self.systemHeaderObj
1888 1893 self.radarControllerHeaderObj
1889 1894 self.dtype
1890 1895
1891 1896 Return:
1892 1897 None
1893 1898 """
1894 1899
1895 1900 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
1896 1901 self.systemHeaderObj.nChannels = self.dataOut.nChannels
1897 1902 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
1898 1903
1899 1904 self.setBasicHeader()
1900 1905
1901 1906 processingHeaderSize = 40 # bytes
1902 1907 self.processingHeaderObj.dtype = 0 # Voltage
1903 1908 self.processingHeaderObj.blockSize = self.__getBlockSize()
1904 1909 self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
1905 1910 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
1906 1911 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
1907 1912 self.processingHeaderObj.processFlags = self.__getProcessFlags()
1908 1913 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
1909 1914 self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
1910 1915 self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
1911 1916
1912 1917 # if self.dataOut.code != None:
1913 1918 # self.processingHeaderObj.code = self.dataOut.code
1914 1919 # self.processingHeaderObj.nCode = self.dataOut.nCode
1915 1920 # self.processingHeaderObj.nBaud = self.dataOut.nBaud
1916 1921 # codesize = int(8 + 4 * self.dataOut.nCode * self.dataOut.nBaud)
1917 1922 # processingHeaderSize += codesize
1918 1923
1919 1924 if self.processingHeaderObj.nWindows != 0:
1920 1925 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
1921 1926 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
1922 1927 self.processingHeaderObj.nHeights = self.dataOut.nHeights
1923 1928 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
1924 1929 processingHeaderSize += 12
1925 1930
1926 1931 self.processingHeaderObj.size = processingHeaderSize
1927 1932
1928 1933 class SpectraReader(JRODataReader):
1929 1934 """
1930 1935 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
1931 1936 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
1932 1937 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
1933 1938
1934 1939 paresCanalesIguales * alturas * perfiles (Self Spectra)
1935 1940 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
1936 1941 canales * alturas (DC Channels)
1937 1942
1938 1943 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
1939 1944 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
1940 1945 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
1941 1946 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
1942 1947
1943 1948 Example:
1944 1949 dpath = "/home/myuser/data"
1945 1950
1946 1951 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
1947 1952
1948 1953 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
1949 1954
1950 1955 readerObj = SpectraReader()
1951 1956
1952 1957 readerObj.setup(dpath, startTime, endTime)
1953 1958
1954 1959 while(True):
1955 1960
1956 1961 readerObj.getData()
1957 1962
1958 1963 print readerObj.data_spc
1959 1964
1960 1965 print readerObj.data_cspc
1961 1966
1962 1967 print readerObj.data_dc
1963 1968
1964 1969 if readerObj.flagNoMoreFiles:
1965 1970 break
1966 1971
1967 1972 """
1968 1973
1969 1974 pts2read_SelfSpectra = 0
1970 1975
1971 1976 pts2read_CrossSpectra = 0
1972 1977
1973 1978 pts2read_DCchannels = 0
1974 1979
1975 1980 ext = ".pdata"
1976 1981
1977 1982 optchar = "P"
1978 1983
1979 1984 dataOut = None
1980 1985
1981 1986 nRdChannels = None
1982 1987
1983 1988 nRdPairs = None
1984 1989
1985 1990 rdPairList = []
1986 1991
1987 1992 def __init__(self):
1988 1993 """
1989 1994 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
1990 1995
1991 1996 Inputs:
1992 1997 dataOut : Objeto de la clase Spectra. Este objeto sera utilizado para
1993 1998 almacenar un perfil de datos cada vez que se haga un requerimiento
1994 1999 (getData). El perfil sera obtenido a partir del buffer de datos,
1995 2000 si el buffer esta vacio se hara un nuevo proceso de lectura de un
1996 2001 bloque de datos.
1997 2002 Si este parametro no es pasado se creara uno internamente.
1998 2003
1999 2004 Affected:
2000 2005 self.dataOut
2001 2006
2002 2007 Return : None
2003 2008 """
2004 2009
2005 2010 self.isConfig = False
2006 2011
2007 2012 self.pts2read_SelfSpectra = 0
2008 2013
2009 2014 self.pts2read_CrossSpectra = 0
2010 2015
2011 2016 self.pts2read_DCchannels = 0
2012 2017
2013 2018 self.datablock = None
2014 2019
2015 2020 self.utc = None
2016 2021
2017 2022 self.ext = ".pdata"
2018 2023
2019 2024 self.optchar = "P"
2020 2025
2021 2026 self.basicHeaderObj = BasicHeader(LOCALTIME)
2022 2027
2023 2028 self.systemHeaderObj = SystemHeader()
2024 2029
2025 2030 self.radarControllerHeaderObj = RadarControllerHeader()
2026 2031
2027 2032 self.processingHeaderObj = ProcessingHeader()
2028 2033
2029 2034 self.online = 0
2030 2035
2031 2036 self.fp = None
2032 2037
2033 2038 self.idFile = None
2034 2039
2035 2040 self.dtype = None
2036 2041
2037 2042 self.fileSizeByHeader = None
2038 2043
2039 2044 self.filenameList = []
2040 2045
2041 2046 self.filename = None
2042 2047
2043 2048 self.fileSize = None
2044 2049
2045 2050 self.firstHeaderSize = 0
2046 2051
2047 2052 self.basicHeaderSize = 24
2048 2053
2049 2054 self.pathList = []
2050 2055
2051 2056 self.lastUTTime = 0
2052 2057
2053 2058 self.maxTimeStep = 30
2054 2059
2055 2060 self.flagNoMoreFiles = 0
2056 2061
2057 2062 self.set = 0
2058 2063
2059 2064 self.path = None
2060 2065
2061 2066 self.delay = 60 #seconds
2062 2067
2063 2068 self.nTries = 3 #quantity tries
2064 2069
2065 2070 self.nFiles = 3 #number of files for searching
2066 2071
2067 2072 self.nReadBlocks = 0
2068 2073
2069 2074 self.flagIsNewFile = 1
2070 2075
2071 2076 self.__isFirstTimeOnline = 1
2072 2077
2073 2078 self.ippSeconds = 0
2074 2079
2075 2080 self.flagTimeBlock = 0
2076 2081
2077 2082 self.flagIsNewBlock = 0
2078 2083
2079 2084 self.nTotalBlocks = 0
2080 2085
2081 2086 self.blocksize = 0
2082 2087
2083 2088 self.dataOut = self.createObjByDefault()
2084 2089
2085 2090 self.profileIndex = 1 #Always
2086 2091
2087 2092
2088 2093 def createObjByDefault(self):
2089 2094
2090 2095 dataObj = Spectra()
2091 2096
2092 2097 return dataObj
2093 2098
2094 2099 def __hasNotDataInBuffer(self):
2095 2100 return 1
2096 2101
2097 2102
2098 2103 def getBlockDimension(self):
2099 2104 """
2100 2105 Obtiene la cantidad de puntos a leer por cada bloque de datos
2101 2106
2102 2107 Affected:
2103 2108 self.nRdChannels
2104 2109 self.nRdPairs
2105 2110 self.pts2read_SelfSpectra
2106 2111 self.pts2read_CrossSpectra
2107 2112 self.pts2read_DCchannels
2108 2113 self.blocksize
2109 2114 self.dataOut.nChannels
2110 2115 self.dataOut.nPairs
2111 2116
2112 2117 Return:
2113 2118 None
2114 2119 """
2115 2120 self.nRdChannels = 0
2116 2121 self.nRdPairs = 0
2117 2122 self.rdPairList = []
2118 2123
2119 2124 for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
2120 2125 if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
2121 2126 self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
2122 2127 else:
2123 2128 self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
2124 2129 self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
2125 2130
2126 2131 pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
2127 2132
2128 2133 self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
2129 2134 self.blocksize = self.pts2read_SelfSpectra
2130 2135
2131 2136 if self.processingHeaderObj.flag_cspc:
2132 2137 self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
2133 2138 self.blocksize += self.pts2read_CrossSpectra
2134 2139
2135 2140 if self.processingHeaderObj.flag_dc:
2136 2141 self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
2137 2142 self.blocksize += self.pts2read_DCchannels
2138 2143
2139 2144 # self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
2140 2145
2141 2146
2142 2147 def readBlock(self):
2143 2148 """
2144 2149 Lee el bloque de datos desde la posicion actual del puntero del archivo
2145 2150 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
2146 2151 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
2147 2152 es seteado a 0
2148 2153
2149 2154 Return: None
2150 2155
2151 2156 Variables afectadas:
2152 2157
2153 2158 self.flagIsNewFile
2154 2159 self.flagIsNewBlock
2155 2160 self.nTotalBlocks
2156 2161 self.data_spc
2157 2162 self.data_cspc
2158 2163 self.data_dc
2159 2164
2160 2165 Exceptions:
2161 2166 Si un bloque leido no es un bloque valido
2162 2167 """
2163 2168 blockOk_flag = False
2164 2169 fpointer = self.fp.tell()
2165 2170
2166 2171 spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
2167 2172 spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
2168 2173
2169 2174 if self.processingHeaderObj.flag_cspc:
2170 2175 cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
2171 2176 cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
2172 2177
2173 2178 if self.processingHeaderObj.flag_dc:
2174 2179 dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
2175 2180 dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
2176 2181
2177 2182
2178 2183 if not(self.processingHeaderObj.shif_fft):
2179 2184 #desplaza a la derecha en el eje 2 determinadas posiciones
2180 2185 shift = int(self.processingHeaderObj.profilesPerBlock/2)
2181 2186 spc = numpy.roll( spc, shift , axis=2 )
2182 2187
2183 2188 if self.processingHeaderObj.flag_cspc:
2184 2189 #desplaza a la derecha en el eje 2 determinadas posiciones
2185 2190 cspc = numpy.roll( cspc, shift, axis=2 )
2186 2191
2187 2192 # self.processingHeaderObj.shif_fft = True
2188 2193
2189 2194 spc = numpy.transpose( spc, (0,2,1) )
2190 2195 self.data_spc = spc
2191 2196
2192 2197 if self.processingHeaderObj.flag_cspc:
2193 2198 cspc = numpy.transpose( cspc, (0,2,1) )
2194 2199 self.data_cspc = cspc['real'] + cspc['imag']*1j
2195 2200 else:
2196 2201 self.data_cspc = None
2197 2202
2198 2203 if self.processingHeaderObj.flag_dc:
2199 2204 self.data_dc = dc['real'] + dc['imag']*1j
2200 2205 else:
2201 2206 self.data_dc = None
2202 2207
2203 2208 self.flagIsNewFile = 0
2204 2209 self.flagIsNewBlock = 1
2205 2210
2206 2211 self.nTotalBlocks += 1
2207 2212 self.nReadBlocks += 1
2208 2213
2209 2214 return 1
2210 2215
2211 2216 def getFirstHeader(self):
2212 2217
2213 2218 self.dataOut.dtype = self.dtype
2214 2219
2215 2220 self.dataOut.nPairs = self.nRdPairs
2216 2221
2217 2222 self.dataOut.pairsList = self.rdPairList
2218 2223
2219 2224 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
2220 2225
2221 2226 self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
2222 2227
2223 2228 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
2224 2229
2225 2230 self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
2226 2231
2227 2232 xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
2228 2233
2229 2234 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
2230 2235
2231 2236 self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
2232 2237
2233 2238 self.dataOut.ippSeconds = self.ippSeconds
2234 2239
2235 2240 self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints
2236 2241
2237 2242 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
2238 2243
2239 2244 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
2240 2245
2241 2246 self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
2242 2247
2243 2248 self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada
2244 2249
2245 2250 self.dataOut.flagDeflipData = True #asumo q la data no esta sin flip
2246 2251
2247 2252 if self.processingHeaderObj.code != None:
2248 2253
2249 2254 self.dataOut.nCode = self.processingHeaderObj.nCode
2250 2255
2251 2256 self.dataOut.nBaud = self.processingHeaderObj.nBaud
2252 2257
2253 2258 self.dataOut.code = self.processingHeaderObj.code
2254 2259
2255 2260 self.dataOut.flagDecodeData = True
2256 2261
2257 2262 def getData(self):
2258 2263 """
2259 2264 Copia el buffer de lectura a la clase "Spectra",
2260 2265 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
2261 2266 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
2262 2267
2263 2268 Return:
2264 2269 0 : Si no hay mas archivos disponibles
2265 2270 1 : Si hizo una buena copia del buffer
2266 2271
2267 2272 Affected:
2268 2273 self.dataOut
2269 2274
2270 2275 self.flagTimeBlock
2271 2276 self.flagIsNewBlock
2272 2277 """
2273 2278
2274 2279 if self.flagNoMoreFiles:
2275 2280 self.dataOut.flagNoData = True
2276 2281 print 'Process finished'
2277 2282 return 0
2278 2283
2279 2284 self.flagTimeBlock = 0
2280 2285 self.flagIsNewBlock = 0
2281 2286
2282 2287 if self.__hasNotDataInBuffer():
2283 2288
2284 2289 if not( self.readNextBlock() ):
2285 2290 self.dataOut.flagNoData = True
2286 2291 return 0
2287 2292
2288 2293 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
2289 2294
2290 2295 if self.data_dc == None:
2291 2296 self.dataOut.flagNoData = True
2292 2297 return 0
2293 2298
2294 2299 self.getBasicHeader()
2295 2300
2296 2301 self.getFirstHeader()
2297 2302
2298 2303 self.dataOut.data_spc = self.data_spc
2299 2304
2300 2305 self.dataOut.data_cspc = self.data_cspc
2301 2306
2302 2307 self.dataOut.data_dc = self.data_dc
2303 2308
2304 2309 self.dataOut.flagNoData = False
2305 2310
2306 2311 self.dataOut.realtime = self.online
2307 2312
2308 2313 return self.dataOut.data_spc
2309 2314
2310 2315
2311 2316 class SpectraWriter(JRODataWriter):
2312 2317
2313 2318 """
2314 2319 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
2315 2320 de los datos siempre se realiza por bloques.
2316 2321 """
2317 2322
2318 2323 ext = ".pdata"
2319 2324
2320 2325 optchar = "P"
2321 2326
2322 2327 shape_spc_Buffer = None
2323 2328
2324 2329 shape_cspc_Buffer = None
2325 2330
2326 2331 shape_dc_Buffer = None
2327 2332
2328 2333 data_spc = None
2329 2334
2330 2335 data_cspc = None
2331 2336
2332 2337 data_dc = None
2333 2338
2334 2339 # dataOut = None
2335 2340
2336 2341 def __init__(self):
2337 2342 """
2338 2343 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
2339 2344
2340 2345 Affected:
2341 2346 self.dataOut
2342 2347 self.basicHeaderObj
2343 2348 self.systemHeaderObj
2344 2349 self.radarControllerHeaderObj
2345 2350 self.processingHeaderObj
2346 2351
2347 2352 Return: None
2348 2353 """
2349 2354
2350 2355 self.isConfig = False
2351 2356
2352 2357 self.nTotalBlocks = 0
2353 2358
2354 2359 self.data_spc = None
2355 2360
2356 2361 self.data_cspc = None
2357 2362
2358 2363 self.data_dc = None
2359 2364
2360 2365 self.fp = None
2361 2366
2362 2367 self.flagIsNewFile = 1
2363 2368
2364 2369 self.nTotalBlocks = 0
2365 2370
2366 2371 self.flagIsNewBlock = 0
2367 2372
2368 2373 self.setFile = None
2369 2374
2370 2375 self.dtype = None
2371 2376
2372 2377 self.path = None
2373 2378
2374 2379 self.noMoreFiles = 0
2375 2380
2376 2381 self.filename = None
2377 2382
2378 2383 self.basicHeaderObj = BasicHeader(LOCALTIME)
2379 2384
2380 2385 self.systemHeaderObj = SystemHeader()
2381 2386
2382 2387 self.radarControllerHeaderObj = RadarControllerHeader()
2383 2388
2384 2389 self.processingHeaderObj = ProcessingHeader()
2385 2390
2386 2391
2387 2392 def hasAllDataInBuffer(self):
2388 2393 return 1
2389 2394
2390 2395
2391 2396 def setBlockDimension(self):
2392 2397 """
2393 2398 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
2394 2399
2395 2400 Affected:
2396 2401 self.shape_spc_Buffer
2397 2402 self.shape_cspc_Buffer
2398 2403 self.shape_dc_Buffer
2399 2404
2400 2405 Return: None
2401 2406 """
2402 2407 self.shape_spc_Buffer = (self.dataOut.nChannels,
2403 2408 self.processingHeaderObj.nHeights,
2404 2409 self.processingHeaderObj.profilesPerBlock)
2405 2410
2406 2411 self.shape_cspc_Buffer = (self.dataOut.nPairs,
2407 2412 self.processingHeaderObj.nHeights,
2408 2413 self.processingHeaderObj.profilesPerBlock)
2409 2414
2410 2415 self.shape_dc_Buffer = (self.dataOut.nChannels,
2411 2416 self.processingHeaderObj.nHeights)
2412 2417
2413 2418
2414 2419 def writeBlock(self):
2415 2420 """
2416 2421 Escribe el buffer en el file designado
2417 2422
2418 2423 Affected:
2419 2424 self.data_spc
2420 2425 self.data_cspc
2421 2426 self.data_dc
2422 2427 self.flagIsNewFile
2423 2428 self.flagIsNewBlock
2424 2429 self.nTotalBlocks
2425 2430 self.nWriteBlocks
2426 2431
2427 2432 Return: None
2428 2433 """
2429 2434
2430 2435 spc = numpy.transpose( self.data_spc, (0,2,1) )
2431 2436 if not( self.processingHeaderObj.shif_fft ):
2432 2437 spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
2433 2438 data = spc.reshape((-1))
2434 2439 data = data.astype(self.dtype[0])
2435 2440 data.tofile(self.fp)
2436 2441
2437 2442 if self.data_cspc != None:
2438 2443 data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )
2439 2444 cspc = numpy.transpose( self.data_cspc, (0,2,1) )
2440 2445 if not( self.processingHeaderObj.shif_fft ):
2441 2446 cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
2442 2447 data['real'] = cspc.real
2443 2448 data['imag'] = cspc.imag
2444 2449 data = data.reshape((-1))
2445 2450 data.tofile(self.fp)
2446 2451
2447 2452 if self.data_dc != None:
2448 2453 data = numpy.zeros( self.shape_dc_Buffer, self.dtype )
2449 2454 dc = self.data_dc
2450 2455 data['real'] = dc.real
2451 2456 data['imag'] = dc.imag
2452 2457 data = data.reshape((-1))
2453 2458 data.tofile(self.fp)
2454 2459
2455 2460 self.data_spc.fill(0)
2456 2461
2457 2462 if self.data_dc != None:
2458 2463 self.data_dc.fill(0)
2459 2464
2460 2465 if self.data_cspc != None:
2461 2466 self.data_cspc.fill(0)
2462 2467
2463 2468 self.flagIsNewFile = 0
2464 2469 self.flagIsNewBlock = 1
2465 2470 self.nTotalBlocks += 1
2466 2471 self.nWriteBlocks += 1
2467 2472 self.blockIndex += 1
2468 2473
2469 2474
2470 2475 def putData(self):
2471 2476 """
2472 2477 Setea un bloque de datos y luego los escribe en un file
2473 2478
2474 2479 Affected:
2475 2480 self.data_spc
2476 2481 self.data_cspc
2477 2482 self.data_dc
2478 2483
2479 2484 Return:
2480 2485 0 : Si no hay data o no hay mas files que puedan escribirse
2481 2486 1 : Si se escribio la data de un bloque en un file
2482 2487 """
2483 2488
2484 2489 if self.dataOut.flagNoData:
2485 2490 return 0
2486 2491
2487 2492 self.flagIsNewBlock = 0
2488 2493
2489 2494 if self.dataOut.flagTimeBlock:
2490 2495 self.data_spc.fill(0)
2491 2496 self.data_cspc.fill(0)
2492 2497 self.data_dc.fill(0)
2493 2498 self.setNextFile()
2494 2499
2495 2500 if self.flagIsNewFile == 0:
2496 2501 self.setBasicHeader()
2497 2502
2498 2503 self.data_spc = self.dataOut.data_spc.copy()
2499 2504 if self.dataOut.data_cspc != None:
2500 2505 self.data_cspc = self.dataOut.data_cspc.copy()
2501 2506 self.data_dc = self.dataOut.data_dc.copy()
2502 2507
2503 2508 # #self.processingHeaderObj.dataBlocksPerFile)
2504 2509 if self.hasAllDataInBuffer():
2505 2510 # self.setFirstHeader()
2506 2511 self.writeNextBlock()
2507 2512
2508 2513 return 1
2509 2514
2510 2515
2511 2516 def __getProcessFlags(self):
2512 2517
2513 2518 processFlags = 0
2514 2519
2515 2520 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
2516 2521 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
2517 2522 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
2518 2523 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
2519 2524 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
2520 2525 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
2521 2526
2522 2527 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
2523 2528
2524 2529
2525 2530
2526 2531 datatypeValueList = [PROCFLAG.DATATYPE_CHAR,
2527 2532 PROCFLAG.DATATYPE_SHORT,
2528 2533 PROCFLAG.DATATYPE_LONG,
2529 2534 PROCFLAG.DATATYPE_INT64,
2530 2535 PROCFLAG.DATATYPE_FLOAT,
2531 2536 PROCFLAG.DATATYPE_DOUBLE]
2532 2537
2533 2538
2534 2539 for index in range(len(dtypeList)):
2535 2540 if self.dataOut.dtype == dtypeList[index]:
2536 2541 dtypeValue = datatypeValueList[index]
2537 2542 break
2538 2543
2539 2544 processFlags += dtypeValue
2540 2545
2541 2546 if self.dataOut.flagDecodeData:
2542 2547 processFlags += PROCFLAG.DECODE_DATA
2543 2548
2544 2549 if self.dataOut.flagDeflipData:
2545 2550 processFlags += PROCFLAG.DEFLIP_DATA
2546 2551
2547 2552 if self.dataOut.code != None:
2548 2553 processFlags += PROCFLAG.DEFINE_PROCESS_CODE
2549 2554
2550 2555 if self.dataOut.nIncohInt > 1:
2551 2556 processFlags += PROCFLAG.INCOHERENT_INTEGRATION
2552 2557
2553 2558 if self.dataOut.data_dc != None:
2554 2559 processFlags += PROCFLAG.SAVE_CHANNELS_DC
2555 2560
2556 2561 return processFlags
2557 2562
2558 2563
2559 2564 def __getBlockSize(self):
2560 2565 '''
2561 2566 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
2562 2567 '''
2563 2568
2564 2569 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
2565 2570 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
2566 2571 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
2567 2572 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
2568 2573 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
2569 2574 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
2570 2575
2571 2576 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
2572 2577 datatypeValueList = [1,2,4,8,4,8]
2573 2578 for index in range(len(dtypeList)):
2574 2579 if self.dataOut.dtype == dtypeList[index]:
2575 2580 datatypeValue = datatypeValueList[index]
2576 2581 break
2577 2582
2578 2583
2579 2584 pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
2580 2585
2581 2586 pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
2582 2587 blocksize = (pts2write_SelfSpectra*datatypeValue)
2583 2588
2584 2589 if self.dataOut.data_cspc != None:
2585 2590 pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
2586 2591 blocksize += (pts2write_CrossSpectra*datatypeValue*2)
2587 2592
2588 2593 if self.dataOut.data_dc != None:
2589 2594 pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
2590 2595 blocksize += (pts2write_DCchannels*datatypeValue*2)
2591 2596
2592 2597 blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
2593 2598
2594 2599 return blocksize
2595 2600
2596 2601 def setFirstHeader(self):
2597 2602
2598 2603 """
2599 2604 Obtiene una copia del First Header
2600 2605
2601 2606 Affected:
2602 2607 self.systemHeaderObj
2603 2608 self.radarControllerHeaderObj
2604 2609 self.dtype
2605 2610
2606 2611 Return:
2607 2612 None
2608 2613 """
2609 2614
2610 2615 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
2611 2616 self.systemHeaderObj.nChannels = self.dataOut.nChannels
2612 2617 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
2613 2618
2614 2619 self.setBasicHeader()
2615 2620
2616 2621 processingHeaderSize = 40 # bytes
2617 2622 self.processingHeaderObj.dtype = 1 # Spectra
2618 2623 self.processingHeaderObj.blockSize = self.__getBlockSize()
2619 2624 self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
2620 2625 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
2621 2626 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
2622 2627 self.processingHeaderObj.processFlags = self.__getProcessFlags()
2623 2628 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
2624 2629 self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
2625 2630 self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
2626 2631 self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT
2627 2632
2628 2633 if self.processingHeaderObj.totalSpectra > 0:
2629 2634 channelList = []
2630 2635 for channel in range(self.dataOut.nChannels):
2631 2636 channelList.append(channel)
2632 2637 channelList.append(channel)
2633 2638
2634 2639 pairsList = []
2635 2640 if self.dataOut.nPairs > 0:
2636 2641 for pair in self.dataOut.pairsList:
2637 2642 pairsList.append(pair[0])
2638 2643 pairsList.append(pair[1])
2639 2644
2640 2645 spectraComb = channelList + pairsList
2641 2646 spectraComb = numpy.array(spectraComb,dtype="u1")
2642 2647 self.processingHeaderObj.spectraComb = spectraComb
2643 2648 sizeOfSpcComb = len(spectraComb)
2644 2649 processingHeaderSize += sizeOfSpcComb
2645 2650
2646 2651 # The processing header should not have information about code
2647 2652 # if self.dataOut.code != None:
2648 2653 # self.processingHeaderObj.code = self.dataOut.code
2649 2654 # self.processingHeaderObj.nCode = self.dataOut.nCode
2650 2655 # self.processingHeaderObj.nBaud = self.dataOut.nBaud
2651 2656 # nCodeSize = 4 # bytes
2652 2657 # nBaudSize = 4 # bytes
2653 2658 # codeSize = 4 # bytes
2654 2659 # sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOut.nCode * self.dataOut.nBaud)
2655 2660 # processingHeaderSize += sizeOfCode
2656 2661
2657 2662 if self.processingHeaderObj.nWindows != 0:
2658 2663 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
2659 2664 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
2660 2665 self.processingHeaderObj.nHeights = self.dataOut.nHeights
2661 2666 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
2662 2667 sizeOfFirstHeight = 4
2663 2668 sizeOfdeltaHeight = 4
2664 2669 sizeOfnHeights = 4
2665 2670 sizeOfWindows = (sizeOfFirstHeight + sizeOfdeltaHeight + sizeOfnHeights)*self.processingHeaderObj.nWindows
2666 2671 processingHeaderSize += sizeOfWindows
2667 2672
2668 2673 self.processingHeaderObj.size = processingHeaderSize
2669 2674
2670 2675 class SpectraHeisWriter(Operation):
2671 2676 # set = None
2672 2677 setFile = None
2673 2678 idblock = None
2674 2679 doypath = None
2675 2680 subfolder = None
2676 2681
2677 2682 def __init__(self):
2678 2683 self.wrObj = FITS()
2679 2684 # self.dataOut = dataOut
2680 2685 self.nTotalBlocks=0
2681 2686 # self.set = None
2682 2687 self.setFile = None
2683 2688 self.idblock = 0
2684 2689 self.wrpath = None
2685 2690 self.doypath = None
2686 2691 self.subfolder = None
2687 2692 self.isConfig = False
2688 2693
2689 2694 def isNumber(str):
2690 2695 """
2691 2696 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
2692 2697
2693 2698 Excepciones:
2694 2699 Si un determinado string no puede ser convertido a numero
2695 2700 Input:
2696 2701 str, string al cual se le analiza para determinar si convertible a un numero o no
2697 2702
2698 2703 Return:
2699 2704 True : si el string es uno numerico
2700 2705 False : no es un string numerico
2701 2706 """
2702 2707 try:
2703 2708 float( str )
2704 2709 return True
2705 2710 except:
2706 2711 return False
2707 2712
2708 2713 def setup(self, dataOut, wrpath):
2709 2714
2710 2715 if not(os.path.exists(wrpath)):
2711 2716 os.mkdir(wrpath)
2712 2717
2713 2718 self.wrpath = wrpath
2714 2719 # self.setFile = 0
2715 2720 self.dataOut = dataOut
2716 2721
2717 2722 def putData(self):
2718 2723 name= time.localtime( self.dataOut.utctime)
2719 2724 ext=".fits"
2720 2725
2721 2726 if self.doypath == None:
2722 2727 self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year,name.tm_yday,time.mktime(datetime.datetime.now().timetuple()))
2723 2728 self.doypath = os.path.join( self.wrpath, self.subfolder )
2724 2729 os.mkdir(self.doypath)
2725 2730
2726 2731 if self.setFile == None:
2727 2732 # self.set = self.dataOut.set
2728 2733 self.setFile = 0
2729 2734 # if self.set != self.dataOut.set:
2730 2735 ## self.set = self.dataOut.set
2731 2736 # self.setFile = 0
2732 2737
2733 2738 #make the filename
2734 2739 file = 'D%4.4d%3.3d_%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
2735 2740
2736 2741 filename = os.path.join(self.wrpath,self.subfolder, file)
2737 2742
2738 2743 idblock = numpy.array([self.idblock],dtype="int64")
2739 2744 header=self.wrObj.cFImage(idblock=idblock,
2740 2745 year=time.gmtime(self.dataOut.utctime).tm_year,
2741 2746 month=time.gmtime(self.dataOut.utctime).tm_mon,
2742 2747 day=time.gmtime(self.dataOut.utctime).tm_mday,
2743 2748 hour=time.gmtime(self.dataOut.utctime).tm_hour,
2744 2749 minute=time.gmtime(self.dataOut.utctime).tm_min,
2745 2750 second=time.gmtime(self.dataOut.utctime).tm_sec)
2746 2751
2747 2752 c=3E8
2748 2753 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
2749 2754 freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)*(c/(2*deltaHeight*1000))
2750 2755
2751 2756 colList = []
2752 2757
2753 2758 colFreq=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
2754 2759
2755 2760 colList.append(colFreq)
2756 2761
2757 2762 nchannel=self.dataOut.nChannels
2758 2763
2759 2764 for i in range(nchannel):
2760 2765 col = self.wrObj.writeData(name="PCh"+str(i+1),
2761 2766 format=str(self.dataOut.nFFTPoints)+'E',
2762 2767 data=10*numpy.log10(self.dataOut.data_spc[i,:]))
2763 2768
2764 2769 colList.append(col)
2765 2770
2766 2771 data=self.wrObj.Ctable(colList=colList)
2767 2772
2768 2773 self.wrObj.CFile(header,data)
2769 2774
2770 2775 self.wrObj.wFile(filename)
2771 2776
2772 2777 #update the setFile
2773 2778 self.setFile += 1
2774 2779 self.idblock += 1
2775 2780
2776 2781 return 1
2777 2782
2778 2783 def run(self, dataOut, **kwargs):
2779 2784
2780 2785 if not(self.isConfig):
2781 2786
2782 2787 self.setup(dataOut, **kwargs)
2783 2788 self.isConfig = True
2784 2789
2785 2790 self.putData()
2786 2791
2787 2792
2788 2793
2789 2794 class ParameterConf:
2790 2795 ELEMENTNAME = 'Parameter'
2791 2796 def __init__(self):
2792 2797 self.name = ''
2793 2798 self.value = ''
2794 2799
2795 2800 def readXml(self, parmElement):
2796 2801 self.name = parmElement.get('name')
2797 2802 self.value = parmElement.get('value')
2798 2803
2799 2804 def getElementName(self):
2800 2805 return self.ELEMENTNAME
2801 2806
2802 2807 class Metadata:
2803 2808
2804 2809 def __init__(self, filename):
2805 2810 self.parmConfObjList = []
2806 2811 self.readXml(filename)
2807 2812
2808 2813 def readXml(self, filename):
2809 2814 self.projectElement = None
2810 2815 self.procUnitConfObjDict = {}
2811 2816 self.projectElement = ElementTree().parse(filename)
2812 2817 self.project = self.projectElement.tag
2813 2818
2814 2819 parmElementList = self.projectElement.getiterator(ParameterConf().getElementName())
2815 2820
2816 2821 for parmElement in parmElementList:
2817 2822 parmConfObj = ParameterConf()
2818 2823 parmConfObj.readXml(parmElement)
2819 2824 self.parmConfObjList.append(parmConfObj)
2820 2825
2821 2826 class FitsWriter(Operation):
2822 2827
2823 2828 def __init__(self):
2824 2829 self.isConfig = False
2825 2830 self.dataBlocksPerFile = None
2826 2831 self.blockIndex = 0
2827 2832 self.flagIsNewFile = 1
2828 2833 self.fitsObj = None
2829 2834 self.optchar = 'P'
2830 2835 self.ext = '.fits'
2831 2836 self.setFile = 0
2832 2837
2833 2838 def setFitsHeader(self, dataOut, metadatafile):
2834 2839
2835 2840 header_data = pyfits.PrimaryHDU()
2836 2841
2837 2842 metadata4fits = Metadata(metadatafile)
2838 2843 for parameter in metadata4fits.parmConfObjList:
2839 2844 parm_name = parameter.name
2840 2845 parm_value = parameter.value
2841 2846
2842 2847 # if parm_value == 'fromdatadatetime':
2843 2848 # value = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
2844 2849 # elif parm_value == 'fromdataheights':
2845 2850 # value = dataOut.nHeights
2846 2851 # elif parm_value == 'fromdatachannel':
2847 2852 # value = dataOut.nChannels
2848 2853 # elif parm_value == 'fromdatasamples':
2849 2854 # value = dataOut.nFFTPoints
2850 2855 # else:
2851 2856 # value = parm_value
2852 2857
2853 2858 header_data.header[parm_name] = parm_value
2854 2859
2855 2860
2856 2861 header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
2857 2862 header_data.header['CHANNELLIST'] = str(dataOut.channelList)
2858 2863 header_data.header['NCHANNELS'] = dataOut.nChannels
2859 2864 #header_data.header['HEIGHTS'] = dataOut.heightList
2860 2865 header_data.header['NHEIGHTS'] = dataOut.nHeights
2861 2866
2862 2867 header_data.header['IPPSECONDS'] = dataOut.ippSeconds
2863 2868 header_data.header['NCOHINT'] = dataOut.nCohInt
2864 2869 header_data.header['NINCOHINT'] = dataOut.nIncohInt
2865 2870 header_data.header['TIMEZONE'] = dataOut.timeZone
2866 2871 header_data.header['NBLOCK'] = self.blockIndex
2867 2872
2868 2873 header_data.writeto(self.filename)
2869 2874
2870 2875 self.addExtension(dataOut.heightList,'HEIGHTLIST')
2871 2876
2872 2877
2873 2878 def setup(self, dataOut, path, dataBlocksPerFile, metadatafile):
2874 2879
2875 2880 self.path = path
2876 2881 self.dataOut = dataOut
2877 2882 self.metadatafile = metadatafile
2878 2883 self.dataBlocksPerFile = dataBlocksPerFile
2879 2884
2880 2885 def open(self):
2881 2886 self.fitsObj = pyfits.open(self.filename, mode='update')
2882 2887
2883 2888
2884 2889 def addExtension(self, data, tagname):
2885 2890 self.open()
2886 2891 extension = pyfits.ImageHDU(data=data, name=tagname)
2887 2892 #extension.header['TAG'] = tagname
2888 2893 self.fitsObj.append(extension)
2889 2894 self.write()
2890 2895
2891 2896 def addData(self, data):
2892 2897 self.open()
2893 2898 extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])
2894 2899 extension.header['UTCTIME'] = self.dataOut.utctime
2895 2900 self.fitsObj.append(extension)
2896 2901 self.blockIndex += 1
2897 2902 self.fitsObj[0].header['NBLOCK'] = self.blockIndex
2898 2903
2899 2904 self.write()
2900 2905
2901 2906 def write(self):
2902 2907
2903 2908 self.fitsObj.flush(verbose=True)
2904 2909 self.fitsObj.close()
2905 2910
2906 2911
2907 2912 def setNextFile(self):
2908 2913
2909 2914 ext = self.ext
2910 2915 path = self.path
2911 2916
2912 2917 timeTuple = time.localtime( self.dataOut.utctime)
2913 2918 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
2914 2919
2915 2920 fullpath = os.path.join( path, subfolder )
2916 2921 if not( os.path.exists(fullpath) ):
2917 2922 os.mkdir(fullpath)
2918 2923 self.setFile = -1 #inicializo mi contador de seteo
2919 2924 else:
2920 2925 filesList = os.listdir( fullpath )
2921 2926 if len( filesList ) > 0:
2922 2927 filesList = sorted( filesList, key=str.lower )
2923 2928 filen = filesList[-1]
2924 2929
2925 2930 if isNumber( filen[8:11] ):
2926 2931 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
2927 2932 else:
2928 2933 self.setFile = -1
2929 2934 else:
2930 2935 self.setFile = -1 #inicializo mi contador de seteo
2931 2936
2932 2937 setFile = self.setFile
2933 2938 setFile += 1
2934 2939
2935 2940 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
2936 2941 timeTuple.tm_year,
2937 2942 timeTuple.tm_yday,
2938 2943 setFile,
2939 2944 ext )
2940 2945
2941 2946 filename = os.path.join( path, subfolder, file )
2942 2947
2943 2948 self.blockIndex = 0
2944 2949 self.filename = filename
2945 2950 self.setFile = setFile
2946 2951 self.flagIsNewFile = 1
2947 2952
2948 2953 print 'Writing the file: %s'%self.filename
2949 2954
2950 2955 self.setFitsHeader(self.dataOut, self.metadatafile)
2951 2956
2952 2957 return 1
2953 2958
2954 2959 def writeBlock(self):
2955 2960 self.addData(self.dataOut.data_spc)
2956 2961 self.flagIsNewFile = 0
2957 2962
2958 2963
2959 2964 def __setNewBlock(self):
2960 2965
2961 2966 if self.flagIsNewFile:
2962 2967 return 1
2963 2968
2964 2969 if self.blockIndex < self.dataBlocksPerFile:
2965 2970 return 1
2966 2971
2967 2972 if not( self.setNextFile() ):
2968 2973 return 0
2969 2974
2970 2975 return 1
2971 2976
2972 2977 def writeNextBlock(self):
2973 2978 if not( self.__setNewBlock() ):
2974 2979 return 0
2975 2980 self.writeBlock()
2976 2981 return 1
2977 2982
2978 2983 def putData(self):
2979 2984 if self.flagIsNewFile:
2980 2985 self.setNextFile()
2981 2986 self.writeNextBlock()
2982 2987
2983 2988 def run(self, dataOut, **kwargs):
2984 2989 if not(self.isConfig):
2985 2990 self.setup(dataOut, **kwargs)
2986 2991 self.isConfig = True
2987 2992 self.putData()
2988 2993
2989 2994
2990 2995 class FitsReader(ProcessingUnit):
2991 2996
2992 2997 # __TIMEZONE = time.timezone
2993 2998
2994 2999 expName = None
2995 3000 datetimestr = None
2996 3001 utc = None
2997 3002 nChannels = None
2998 3003 nSamples = None
2999 3004 dataBlocksPerFile = None
3000 3005 comments = None
3001 3006 lastUTTime = None
3002 3007 header_dict = None
3003 3008 data = None
3004 3009 data_header_dict = None
3005 3010
3006 3011 def __init__(self):
3007 3012 self.isConfig = False
3008 3013 self.ext = '.fits'
3009 3014 self.setFile = 0
3010 3015 self.flagNoMoreFiles = 0
3011 3016 self.flagIsNewFile = 1
3012 3017 self.flagTimeBlock = None
3013 3018 self.fileIndex = None
3014 3019 self.filename = None
3015 3020 self.fileSize = None
3016 3021 self.fitsObj = None
3017 3022 self.timeZone = None
3018 3023 self.nReadBlocks = 0
3019 3024 self.nTotalBlocks = 0
3020 3025 self.dataOut = self.createObjByDefault()
3021 3026 self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()
3022 3027 self.blockIndex = 1
3023 3028
3024 3029 def createObjByDefault(self):
3025 3030
3026 3031 dataObj = Fits()
3027 3032
3028 3033 return dataObj
3029 3034
3030 3035 def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):
3031 3036 try:
3032 3037 fitsObj = pyfits.open(filename,'readonly')
3033 3038 except:
3034 3039 raise IOError, "The file %s can't be opened" %(filename)
3035 3040
3036 3041 header = fitsObj[0].header
3037 3042 struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")
3038 3043 utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS
3039 3044
3040 3045 ltc = utc
3041 3046 if useLocalTime:
3042 3047 ltc -= time.timezone
3043 3048 thisDatetime = datetime.datetime.utcfromtimestamp(ltc)
3044 3049 thisTime = thisDatetime.time()
3045 3050
3046 3051 if not ((startTime <= thisTime) and (endTime > thisTime)):
3047 3052 return None
3048 3053
3049 3054 return thisDatetime
3050 3055
3051 3056 def __setNextFileOnline(self):
3052 3057 raise ValueError, "No implemented"
3053 3058
3054 3059 def __setNextFileOffline(self):
3055 3060 idFile = self.fileIndex
3056 3061
3057 3062 while (True):
3058 3063 idFile += 1
3059 3064 if not(idFile < len(self.filenameList)):
3060 3065 self.flagNoMoreFiles = 1
3061 3066 print "No more Files"
3062 3067 return 0
3063 3068
3064 3069 filename = self.filenameList[idFile]
3065 3070
3066 3071 # if not(self.__verifyFile(filename)):
3067 3072 # continue
3068 3073
3069 3074 fileSize = os.path.getsize(filename)
3070 3075 fitsObj = pyfits.open(filename,'readonly')
3071 3076 break
3072 3077
3073 3078 self.flagIsNewFile = 1
3074 3079 self.fileIndex = idFile
3075 3080 self.filename = filename
3076 3081 self.fileSize = fileSize
3077 3082 self.fitsObj = fitsObj
3078 3083 self.blockIndex = 0
3079 3084 print "Setting the file: %s"%self.filename
3080 3085
3081 3086 return 1
3082 3087
3083 3088 def readHeader(self):
3084 3089 headerObj = self.fitsObj[0]
3085 3090
3086 3091 self.header_dict = headerObj.header
3087 3092 if 'EXPNAME' in headerObj.header.keys():
3088 3093 self.expName = headerObj.header['EXPNAME']
3089 3094
3090 3095 if 'DATATYPE' in headerObj.header.keys():
3091 3096 self.dataType = headerObj.header['DATATYPE']
3092 3097
3093 3098 self.datetimestr = headerObj.header['DATETIME']
3094 3099 channelList = headerObj.header['CHANNELLIST']
3095 3100 channelList = channelList.split('[')
3096 3101 channelList = channelList[1].split(']')
3097 3102 channelList = channelList[0].split(',')
3098 3103 channelList = [int(ch) for ch in channelList]
3099 3104 self.channelList = channelList
3100 3105 self.nChannels = headerObj.header['NCHANNELS']
3101 3106 self.nHeights = headerObj.header['NHEIGHTS']
3102 3107 self.ippSeconds = headerObj.header['IPPSECONDS']
3103 3108 self.nCohInt = headerObj.header['NCOHINT']
3104 3109 self.nIncohInt = headerObj.header['NINCOHINT']
3105 3110 self.dataBlocksPerFile = headerObj.header['NBLOCK']
3106 3111 self.timeZone = headerObj.header['TIMEZONE']
3107 3112
3108 3113 self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
3109 3114
3110 3115 if 'COMMENT' in headerObj.header.keys():
3111 3116 self.comments = headerObj.header['COMMENT']
3112 3117
3113 3118 self.readHeightList()
3114 3119
3115 3120 def readHeightList(self):
3116 3121 self.blockIndex = self.blockIndex + 1
3117 3122 obj = self.fitsObj[self.blockIndex]
3118 3123 self.heightList = obj.data
3119 3124 self.blockIndex = self.blockIndex + 1
3120 3125
3121 3126 def readExtension(self):
3122 3127 obj = self.fitsObj[self.blockIndex]
3123 3128 self.heightList = obj.data
3124 3129 self.blockIndex = self.blockIndex + 1
3125 3130
3126 3131 def setNextFile(self):
3127 3132
3128 3133 if self.online:
3129 3134 newFile = self.__setNextFileOnline()
3130 3135 else:
3131 3136 newFile = self.__setNextFileOffline()
3132 3137
3133 3138 if not(newFile):
3134 3139 return 0
3135 3140
3136 3141 self.readHeader()
3137 3142
3138 3143 self.nReadBlocks = 0
3139 3144 # self.blockIndex = 1
3140 3145 return 1
3141 3146
3142 3147 def __searchFilesOffLine(self,
3143 3148 path,
3144 3149 startDate,
3145 3150 endDate,
3146 3151 startTime=datetime.time(0,0,0),
3147 3152 endTime=datetime.time(23,59,59),
3148 3153 set=None,
3149 3154 expLabel='',
3150 3155 ext='.fits',
3151 3156 walk=True):
3152 3157
3153 3158 pathList = []
3154 3159
3155 3160 if not walk:
3156 3161 pathList.append(path)
3157 3162
3158 3163 else:
3159 3164 dirList = []
3160 3165 for thisPath in os.listdir(path):
3161 3166 if not os.path.isdir(os.path.join(path,thisPath)):
3162 3167 continue
3163 3168 if not isDoyFolder(thisPath):
3164 3169 continue
3165 3170
3166 3171 dirList.append(thisPath)
3167 3172
3168 3173 if not(dirList):
3169 3174 return None, None
3170 3175
3171 3176 thisDate = startDate
3172 3177
3173 3178 while(thisDate <= endDate):
3174 3179 year = thisDate.timetuple().tm_year
3175 3180 doy = thisDate.timetuple().tm_yday
3176 3181
3177 3182 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
3178 3183 if len(matchlist) == 0:
3179 3184 thisDate += datetime.timedelta(1)
3180 3185 continue
3181 3186 for match in matchlist:
3182 3187 pathList.append(os.path.join(path,match,expLabel))
3183 3188
3184 3189 thisDate += datetime.timedelta(1)
3185 3190
3186 3191 if pathList == []:
3187 3192 print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
3188 3193 return None, None
3189 3194
3190 3195 print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
3191 3196
3192 3197 filenameList = []
3193 3198 datetimeList = []
3194 3199
3195 3200 for i in range(len(pathList)):
3196 3201
3197 3202 thisPath = pathList[i]
3198 3203
3199 3204 fileList = glob.glob1(thisPath, "*%s" %ext)
3200 3205 fileList.sort()
3201 3206
3202 3207 for file in fileList:
3203 3208
3204 3209 filename = os.path.join(thisPath,file)
3205 3210 thisDatetime = self.isFileinThisTime(filename, startTime, endTime)
3206 3211
3207 3212 if not(thisDatetime):
3208 3213 continue
3209 3214
3210 3215 filenameList.append(filename)
3211 3216 datetimeList.append(thisDatetime)
3212 3217
3213 3218 if not(filenameList):
3214 3219 print "Any file was found for the time range %s - %s" %(startTime, endTime)
3215 3220 return None, None
3216 3221
3217 3222 print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
3218 3223 print
3219 3224
3220 3225 for i in range(len(filenameList)):
3221 3226 print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
3222 3227
3223 3228 self.filenameList = filenameList
3224 3229 self.datetimeList = datetimeList
3225 3230
3226 3231 return pathList, filenameList
3227 3232
3228 3233 def setup(self, path=None,
3229 3234 startDate=None,
3230 3235 endDate=None,
3231 3236 startTime=datetime.time(0,0,0),
3232 3237 endTime=datetime.time(23,59,59),
3233 3238 set=0,
3234 3239 expLabel = "",
3235 3240 ext = None,
3236 3241 online = False,
3237 3242 delay = 60,
3238 3243 walk = True):
3239 3244
3240 3245 if path == None:
3241 3246 raise ValueError, "The path is not valid"
3242 3247
3243 3248 if ext == None:
3244 3249 ext = self.ext
3245 3250
3246 3251 if not(online):
3247 3252 print "Searching files in offline mode ..."
3248 3253 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
3249 3254 startTime=startTime, endTime=endTime,
3250 3255 set=set, expLabel=expLabel, ext=ext,
3251 3256 walk=walk)
3252 3257
3253 3258 if not(pathList):
3254 3259 print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
3255 3260 datetime.datetime.combine(startDate,startTime).ctime(),
3256 3261 datetime.datetime.combine(endDate,endTime).ctime())
3257 3262
3258 3263 sys.exit(-1)
3259 3264
3260 3265 self.fileIndex = -1
3261 3266 self.pathList = pathList
3262 3267 self.filenameList = filenameList
3263 3268
3264 3269 self.online = online
3265 3270 self.delay = delay
3266 3271 ext = ext.lower()
3267 3272 self.ext = ext
3268 3273
3269 3274 if not(self.setNextFile()):
3270 3275 if (startDate!=None) and (endDate!=None):
3271 3276 print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
3272 3277 elif startDate != None:
3273 3278 print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
3274 3279 else:
3275 3280 print "No files"
3276 3281
3277 3282 sys.exit(-1)
3278 3283
3279 3284
3280 3285
3281 3286 def readBlock(self):
3282 3287 dataObj = self.fitsObj[self.blockIndex]
3283 3288
3284 3289 self.data = dataObj.data
3285 3290 self.data_header_dict = dataObj.header
3286 3291 self.utc = self.data_header_dict['UTCTIME']
3287 3292
3288 3293 self.flagIsNewFile = 0
3289 3294 self.blockIndex += 1
3290 3295 self.nTotalBlocks += 1
3291 3296 self.nReadBlocks += 1
3292 3297
3293 3298 return 1
3294 3299
3295 3300 def __jumpToLastBlock(self):
3296 3301 raise ValueError, "No implemented"
3297 3302
3298 3303 def __waitNewBlock(self):
3299 3304 """
3300 3305 Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
3301 3306
3302 3307 Si el modo de lectura es OffLine siempre retorn 0
3303 3308 """
3304 3309 if not self.online:
3305 3310 return 0
3306 3311
3307 3312 if (self.nReadBlocks >= self.dataBlocksPerFile):
3308 3313 return 0
3309 3314
3310 3315 currentPointer = self.fp.tell()
3311 3316
3312 3317 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
3313 3318
3314 3319 for nTries in range( self.nTries ):
3315 3320
3316 3321 self.fp.close()
3317 3322 self.fp = open( self.filename, 'rb' )
3318 3323 self.fp.seek( currentPointer )
3319 3324
3320 3325 self.fileSize = os.path.getsize( self.filename )
3321 3326 currentSize = self.fileSize - currentPointer
3322 3327
3323 3328 if ( currentSize >= neededSize ):
3324 3329 self.__rdBasicHeader()
3325 3330 return 1
3326 3331
3327 3332 print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
3328 3333 time.sleep( self.delay )
3329 3334
3330 3335
3331 3336 return 0
3332 3337
3333 3338 def __setNewBlock(self):
3334 3339
3335 3340 if self.online:
3336 3341 self.__jumpToLastBlock()
3337 3342
3338 3343 if self.flagIsNewFile:
3339 3344 return 1
3340 3345
3341 3346 self.lastUTTime = self.utc
3342 3347
3343 3348 if self.online:
3344 3349 if self.__waitNewBlock():
3345 3350 return 1
3346 3351
3347 3352 if self.nReadBlocks < self.dataBlocksPerFile:
3348 3353 return 1
3349 3354
3350 3355 if not(self.setNextFile()):
3351 3356 return 0
3352 3357
3353 3358 deltaTime = self.utc - self.lastUTTime
3354 3359
3355 3360 self.flagTimeBlock = 0
3356 3361
3357 3362 if deltaTime > self.maxTimeStep:
3358 3363 self.flagTimeBlock = 1
3359 3364
3360 3365 return 1
3361 3366
3362 3367
3363 3368 def readNextBlock(self):
3364 3369 if not(self.__setNewBlock()):
3365 3370 return 0
3366 3371
3367 3372 if not(self.readBlock()):
3368 3373 return 0
3369 3374
3370 3375 return 1
3371 3376
3372 3377
3373 3378 def getData(self):
3374 3379
3375 3380 if self.flagNoMoreFiles:
3376 3381 self.dataOut.flagNoData = True
3377 3382 print 'Process finished'
3378 3383 return 0
3379 3384
3380 3385 self.flagTimeBlock = 0
3381 3386 self.flagIsNewBlock = 0
3382 3387
3383 3388 if not(self.readNextBlock()):
3384 3389 return 0
3385 3390
3386 3391 if self.data == None:
3387 3392 self.dataOut.flagNoData = True
3388 3393 return 0
3389 3394
3390 3395 self.dataOut.data = self.data
3391 3396 self.dataOut.data_header = self.data_header_dict
3392 3397 self.dataOut.utctime = self.utc
3393 3398
3394 3399 self.dataOut.header = self.header_dict
3395 3400 self.dataOut.expName = self.expName
3396 3401 self.dataOut.nChannels = self.nChannels
3397 3402 self.dataOut.timeZone = self.timeZone
3398 3403 self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
3399 3404 self.dataOut.comments = self.comments
3400 3405 self.dataOut.timeInterval = self.timeInterval
3401 3406 self.dataOut.channelList = self.channelList
3402 3407 self.dataOut.heightList = self.heightList
3403 3408 self.dataOut.flagNoData = False
3404 3409
3405 3410 return self.dataOut.data
3406 3411
3407 3412 def run(self, **kwargs):
3408 3413
3409 3414 if not(self.isConfig):
3410 3415 self.setup(**kwargs)
3411 3416 self.isConfig = True
3412 3417
3413 3418 self.getData() No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now