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