##// END OF EJS Templates
schain
RSS
JRODATA: timeInterval is a property now
Miguel Valdez -
r526:00d6236d4cbc
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,983 +1,1015
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 copy
8 8 import numpy
9 9 import datetime
10 10
11 11 from jroheaderIO import SystemHeader, RadarControllerHeader
12 12
13 13 def getNumpyDtype(dataTypeCode):
14 14
15 15 if dataTypeCode == 0:
16 16 numpyDtype = numpy.dtype([('real','<i1'),('imag','<i1')])
17 17 elif dataTypeCode == 1:
18 18 numpyDtype = numpy.dtype([('real','<i2'),('imag','<i2')])
19 19 elif dataTypeCode == 2:
20 20 numpyDtype = numpy.dtype([('real','<i4'),('imag','<i4')])
21 21 elif dataTypeCode == 3:
22 22 numpyDtype = numpy.dtype([('real','<i8'),('imag','<i8')])
23 23 elif dataTypeCode == 4:
24 24 numpyDtype = numpy.dtype([('real','<f4'),('imag','<f4')])
25 25 elif dataTypeCode == 5:
26 26 numpyDtype = numpy.dtype([('real','<f8'),('imag','<f8')])
27 27 else:
28 28 raise ValueError, 'dataTypeCode was not defined'
29 29
30 30 return numpyDtype
31 31
32 32 def getDataTypeCode(numpyDtype):
33 33
34 34 if numpyDtype == numpy.dtype([('real','<i1'),('imag','<i1')]):
35 35 datatype = 0
36 36 elif numpyDtype == numpy.dtype([('real','<i2'),('imag','<i2')]):
37 37 datatype = 1
38 38 elif numpyDtype == numpy.dtype([('real','<i4'),('imag','<i4')]):
39 39 datatype = 2
40 40 elif numpyDtype == numpy.dtype([('real','<i8'),('imag','<i8')]):
41 41 datatype = 3
42 42 elif numpyDtype == numpy.dtype([('real','<f4'),('imag','<f4')]):
43 43 datatype = 4
44 44 elif numpyDtype == numpy.dtype([('real','<f8'),('imag','<f8')]):
45 45 datatype = 5
46 46 else:
47 47 datatype = None
48 48
49 49 return datatype
50 50
51 51 def hildebrand_sekhon(data, navg):
52 52
53 53 data = data.copy()
54 54
55 55 sortdata = numpy.sort(data,axis=None)
56 56 lenOfData = len(sortdata)
57 57 nums_min = lenOfData/10
58 58
59 59 if (lenOfData/10) > 2:
60 60 nums_min = lenOfData/10
61 61 else:
62 62 nums_min = 2
63 63
64 64 sump = 0.
65 65
66 66 sumq = 0.
67 67
68 68 j = 0
69 69
70 70 cont = 1
71 71
72 72 while((cont==1)and(j<lenOfData)):
73 73
74 74 sump += sortdata[j]
75 75
76 76 sumq += sortdata[j]**2
77 77
78 78 j += 1
79 79
80 80 if j > nums_min:
81 81 rtest = float(j)/(j-1) + 1.0/navg
82 82 if ((sumq*j) > (rtest*sump**2)):
83 83 j = j - 1
84 84 sump = sump - sortdata[j]
85 85 sumq = sumq - sortdata[j]**2
86 86 cont = 0
87 87
88 88 lnoise = sump /j
89 89 stdv = numpy.sqrt((sumq - lnoise**2)/(j - 1))
90 90 return lnoise
91 91
92 92 class Beam:
93 93 def __init__(self):
94 94 self.codeList = []
95 95 self.azimuthList = []
96 96 self.zenithList = []
97 97
98 98 class GenericData(object):
99 99
100 100 flagNoData = True
101 101
102 102 def __init__(self):
103 103
104 104 raise ValueError, "This class has not been implemented"
105 105
106 106 def copy(self, inputObj=None):
107 107
108 108 if inputObj == None:
109 109 return copy.deepcopy(self)
110 110
111 111 for key in inputObj.__dict__.keys():
112 112 self.__dict__[key] = inputObj.__dict__[key]
113 113
114 114 def deepcopy(self):
115 115
116 116 return copy.deepcopy(self)
117 117
118 118 def isEmpty(self):
119 119
120 120 return self.flagNoData
121 121
122 122 class JROData(GenericData):
123 123
124 124 # m_BasicHeader = BasicHeader()
125 125 # m_ProcessingHeader = ProcessingHeader()
126 126
127 127 systemHeaderObj = SystemHeader()
128 128
129 129 radarControllerHeaderObj = RadarControllerHeader()
130 130
131 131 # data = None
132 132
133 133 type = None
134 134
135 135 datatype = None #dtype but in string
136 136
137 137 # dtype = None
138 138
139 139 # nChannels = None
140 140
141 141 # nHeights = None
142 142
143 143 nProfiles = None
144 144
145 145 heightList = None
146 146
147 147 channelList = None
148 148
149 149 flagTimeBlock = False
150 150
151 151 useLocalTime = False
152 152
153 153 utctime = None
154 154
155 155 timeZone = None
156 156
157 157 dstFlag = None
158 158
159 159 errorCount = None
160 160
161 161 blocksize = None
162 162
163 163 nCode = None
164 164
165 165 nBaud = None
166 166
167 167 code = None
168 168
169 169 flagDecodeData = False #asumo q la data no esta decodificada
170 170
171 171 flagDeflipData = False #asumo q la data no esta sin flip
172 172
173 173 flagShiftFFT = False
174 174
175 175 # ippSeconds = None
176 176
177 timeInterval = None
177 # timeInterval = None
178 178
179 179 nCohInt = None
180 180
181 181 noise = None
182 182
183 183 windowOfFilter = 1
184 184
185 185 #Speed of ligth
186 186 C = 3e8
187 187
188 188 frequency = 49.92e6
189 189
190 190 realtime = False
191 191
192 192 beacon_heiIndexList = None
193 193
194 194 last_block = None
195 195
196 196 blocknow = None
197 197
198 198 azimuth = None
199 199
200 200 zenith = None
201 201
202 202 beam = Beam()
203 203
204 204 def __init__(self):
205 205
206 206 raise ValueError, "This class has not been implemented"
207 207
208 208 def getNoise(self):
209 209
210 210 raise ValueError, "Not implemented"
211 211
212 212 def getNChannels(self):
213 213
214 214 return len(self.channelList)
215 215
216 216 def getChannelIndexList(self):
217 217
218 218 return range(self.nChannels)
219 219
220 220 def getNHeights(self):
221 221
222 222 return len(self.heightList)
223 223
224 224 def getHeiRange(self, extrapoints=0):
225 225
226 226 heis = self.heightList
227 227 # deltah = self.heightList[1] - self.heightList[0]
228 228 #
229 229 # heis.append(self.heightList[-1])
230 230
231 231 return heis
232 232
233 233 def getltctime(self):
234 234
235 235 if self.useLocalTime:
236 236 return self.utctime - self.timeZone*60
237 237
238 238 return self.utctime
239 239
240 240 def getDatatime(self):
241 241
242 242 datatimeValue = datetime.datetime.utcfromtimestamp(self.ltctime)
243 243 return datatimeValue
244 244
245 245 def getTimeRange(self):
246 246
247 247 datatime = []
248 248
249 249 datatime.append(self.ltctime)
250 250 datatime.append(self.ltctime + self.timeInterval)
251 251
252 252 datatime = numpy.array(datatime)
253 253
254 254 return datatime
255 255
256 256 def getFmax(self):
257 257
258 258 PRF = 1./(self.ippSeconds * self.nCohInt)
259 259
260 260 fmax = PRF/2.
261 261
262 262 return fmax
263 263
264 264 def getVmax(self):
265 265
266 266 _lambda = self.C/self.frequency
267 267
268 268 vmax = self.getFmax() * _lambda
269 269
270 270 return vmax
271 271
272 272 def get_ippSeconds(self):
273 273 '''
274 274 '''
275 275 return self.radarControllerHeaderObj.ippSeconds
276 276
277 277 def set_ippSeconds(self, ippSeconds):
278 278 '''
279 279 '''
280 280
281 281 self.radarControllerHeaderObj.ippSeconds = ippSeconds
282 282
283 283 return
284 284
285 285 def get_dtype(self):
286 286 '''
287 287 '''
288 288 return getNumpyDtype(self.datatype)
289 289
290 290 def set_dtype(self, numpyDtype):
291 291 '''
292 292 '''
293 293
294 294 self.datatype = getDataTypeCode(numpyDtype)
295 295
296 # def getTimeInterval(self):
297 #
298 # raise IOError, "This method should be implemented inside each Class"
299
296 300 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
297 301 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
298 302 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
299 303 #noise = property(getNoise, "I'm the 'nHeights' property.")
300 304 datatime = property(getDatatime, "I'm the 'datatime' property")
301 305 ltctime = property(getltctime, "I'm the 'ltctime' property")
302 306 ippSeconds = property(get_ippSeconds, set_ippSeconds)
303 307 dtype = property(get_dtype, set_dtype)
308 # timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
304 309
305 310 class Voltage(JROData):
306 311
307 312 #data es un numpy array de 2 dmensiones (canales, alturas)
308 313 data = None
309 314
310 315 def __init__(self):
311 316 '''
312 317 Constructor
313 318 '''
314 319
315 320 self.radarControllerHeaderObj = RadarControllerHeader()
316 321
317 322 self.systemHeaderObj = SystemHeader()
318 323
319 324 self.type = "Voltage"
320 325
321 326 self.data = None
322 327
323 328 # self.dtype = None
324 329
325 330 # self.nChannels = 0
326 331
327 332 # self.nHeights = 0
328 333
329 334 self.nProfiles = None
330 335
331 336 self.heightList = None
332 337
333 338 self.channelList = None
334 339
335 340 # self.channelIndexList = None
336 341
337 342 self.flagNoData = True
338 343
339 344 self.flagTimeBlock = False
340 345
341 346 self.utctime = None
342 347
343 348 self.timeZone = None
344 349
345 350 self.dstFlag = None
346 351
347 352 self.errorCount = None
348 353
349 354 self.nCohInt = None
350 355
351 356 self.blocksize = None
352 357
353 358 self.flagDecodeData = False #asumo q la data no esta decodificada
354 359
355 360 self.flagDeflipData = False #asumo q la data no esta sin flip
356 361
357 362 self.flagShiftFFT = False
358 363
364 self.flagDataAsBlock = False #Asumo que la data es leida perfil a perfil
359 365
360 366 def getNoisebyHildebrand(self):
361 367 """
362 368 Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
363 369
364 370 Return:
365 371 noiselevel
366 372 """
367 373
368 374 for channel in range(self.nChannels):
369 375 daux = self.data_spc[channel,:,:]
370 376 self.noise[channel] = hildebrand_sekhon(daux, self.nCohInt)
371 377
372 378 return self.noise
373 379
374 380 def getNoise(self, type = 1):
375 381
376 382 self.noise = numpy.zeros(self.nChannels)
377 383
378 384 if type == 1:
379 385 noise = self.getNoisebyHildebrand()
380 386
381 387 return 10*numpy.log10(noise)
382 388
389 def getTimeInterval(self):
390
391 timeInterval = self.ippSeconds * self.nCohInt
392
393 return timeInterval
394
383 395 noise = property(getNoise, "I'm the 'nHeights' property.")
396 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
384 397
385 398 class Spectra(JROData):
386 399
387 400 #data es un numpy array de 2 dmensiones (canales, perfiles, alturas)
388 401 data_spc = None
389 402
390 403 #data es un numpy array de 2 dmensiones (canales, pares, alturas)
391 404 data_cspc = None
392 405
393 406 #data es un numpy array de 2 dmensiones (canales, alturas)
394 407 data_dc = None
395 408
396 409 nFFTPoints = None
397 410
398 411 # nPairs = None
399 412
400 413 pairsList = None
401 414
402 415 nIncohInt = None
403 416
404 417 wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia
405 418
406 419 nCohInt = None #se requiere para determinar el valor de timeInterval
407 420
408 421 ippFactor = None
409 422
410 423 def __init__(self):
411 424 '''
412 425 Constructor
413 426 '''
414 427
415 428 self.radarControllerHeaderObj = RadarControllerHeader()
416 429
417 430 self.systemHeaderObj = SystemHeader()
418 431
419 432 self.type = "Spectra"
420 433
421 434 # self.data = None
422 435
423 436 # self.dtype = None
424 437
425 438 # self.nChannels = 0
426 439
427 440 # self.nHeights = 0
428 441
429 442 self.nProfiles = None
430 443
431 444 self.heightList = None
432 445
433 446 self.channelList = None
434 447
435 448 # self.channelIndexList = None
436 449
437 450 self.pairsList = None
438 451
439 452 self.flagNoData = True
440 453
441 454 self.flagTimeBlock = False
442 455
443 456 self.utctime = None
444 457
445 458 self.nCohInt = None
446 459
447 460 self.nIncohInt = None
448 461
449 462 self.blocksize = None
450 463
451 464 self.nFFTPoints = None
452 465
453 466 self.wavelength = None
454 467
455 468 self.flagDecodeData = False #asumo q la data no esta decodificada
456 469
457 470 self.flagDeflipData = False #asumo q la data no esta sin flip
458 471
459 472 self.flagShiftFFT = False
460 473
461 474 self.ippFactor = 1
462 475
463 476 #self.noise = None
464 477
465 478 self.beacon_heiIndexList = []
466 479
467 480 self.noise_estimation = None
468 481
469 482
470 483 def getNoisebyHildebrand(self):
471 484 """
472 485 Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
473 486
474 487 Return:
475 488 noiselevel
476 489 """
477 490
478 491 noise = numpy.zeros(self.nChannels)
479 492 for channel in range(self.nChannels):
480 493 daux = self.data_spc[channel,:,:]
481 494 noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
482 495
483 496 return noise
484 497
485 498 def getNoise(self):
486 499 if self.noise_estimation != None:
487 500 return self.noise_estimation #this was estimated by getNoise Operation defined in jroproc_spectra.py
488 501 else:
489 502 noise = self.getNoisebyHildebrand()
490 503 return noise
491 504
492 505
493 506 def getFreqRange(self, extrapoints=0):
494 507
495 508 deltafreq = self.getFmax() / (self.nFFTPoints*self.ippFactor)
496 509 freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
497 510
498 511 return freqrange
499 512
500 513 def getVelRange(self, extrapoints=0):
501 514
502 515 deltav = self.getVmax() / (self.nFFTPoints*self.ippFactor)
503 516 velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltav/2
504 517
505 518 return velrange
506 519
507 520 def getNPairs(self):
508 521
509 522 return len(self.pairsList)
510 523
511 524 def getPairsIndexList(self):
512 525
513 526 return range(self.nPairs)
514 527
515 528 def getNormFactor(self):
516 529 pwcode = 1
517 530 if self.flagDecodeData:
518 531 pwcode = numpy.sum(self.code[0]**2)
519 532 #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
520 533 normFactor = self.nProfiles*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
521 534
522 535 return normFactor
523 536
524 537 def getFlagCspc(self):
525 538
526 539 if self.data_cspc == None:
527 540 return True
528 541
529 542 return False
530 543
531 544 def getFlagDc(self):
532 545
533 546 if self.data_dc == None:
534 547 return True
535 548
536 549 return False
537 550
551 def getTimeInterval(self):
552
553 timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles
554
555 return timeInterval
556
538 557 nPairs = property(getNPairs, "I'm the 'nPairs' property.")
539 558 pairsIndexList = property(getPairsIndexList, "I'm the 'pairsIndexList' property.")
540 559 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
541 560 flag_cspc = property(getFlagCspc)
542 561 flag_dc = property(getFlagDc)
543 562 noise = property(getNoise, "I'm the 'nHeights' property.")
563 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
544 564
545 565 class SpectraHeis(Spectra):
546 566
547 567 data_spc = None
548 568
549 569 data_cspc = None
550 570
551 571 data_dc = None
552 572
553 573 nFFTPoints = None
554 574
555 575 # nPairs = None
556 576
557 577 pairsList = None
558 578
559 579 nIncohInt = None
560 580
561 581 def __init__(self):
562 582
563 583 self.radarControllerHeaderObj = RadarControllerHeader()
564 584
565 585 self.systemHeaderObj = SystemHeader()
566 586
567 587 self.type = "SpectraHeis"
568 588
569 589 # self.dtype = None
570 590
571 591 # self.nChannels = 0
572 592
573 593 # self.nHeights = 0
574 594
575 595 self.nProfiles = None
576 596
577 597 self.heightList = None
578 598
579 599 self.channelList = None
580 600
581 601 # self.channelIndexList = None
582 602
583 603 self.flagNoData = True
584 604
585 605 self.flagTimeBlock = False
586 606
587 607 # self.nPairs = 0
588 608
589 609 self.utctime = None
590 610
591 611 self.blocksize = None
592 612
593 613 def getNormFactor(self):
594 614 pwcode = 1
595 615 if self.flagDecodeData:
596 616 pwcode = numpy.sum(self.code[0]**2)
597 617
598 618 normFactor = self.nIncohInt*self.nCohInt*pwcode
599 619
600 620 return normFactor
601 621
622 def getTimeInterval(self):
623
624 timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
625
626 return timeInterval
627
602 628 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
629 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
603 630
604 631 class Fits:
605 632
606 633 heightList = None
607 634
608 635 channelList = None
609 636
610 637 flagNoData = True
611 638
612 639 flagTimeBlock = False
613 640
614 641 useLocalTime = False
615 642
616 643 utctime = None
617 644
618 645 timeZone = None
619 646
620 647 # ippSeconds = None
621 648
622 timeInterval = None
649 # timeInterval = None
623 650
624 651 nCohInt = None
625 652
626 653 nIncohInt = None
627 654
628 655 noise = None
629 656
630 657 windowOfFilter = 1
631 658
632 659 #Speed of ligth
633 660 C = 3e8
634 661
635 662 frequency = 49.92e6
636 663
637 664 realtime = False
638 665
639 666
640 667 def __init__(self):
641 668
642 669 self.type = "Fits"
643 670
644 671 self.nProfiles = None
645 672
646 673 self.heightList = None
647 674
648 675 self.channelList = None
649 676
650 677 # self.channelIndexList = None
651 678
652 679 self.flagNoData = True
653 680
654 681 self.utctime = None
655 682
656 683 self.nCohInt = None
657 684
658 685 self.nIncohInt = None
659 686
660 687 self.useLocalTime = True
661 688
662 689 # self.utctime = None
663 690 # self.timeZone = None
664 691 # self.ltctime = None
665 692 # self.timeInterval = None
666 693 # self.header = None
667 694 # self.data_header = None
668 695 # self.data = None
669 696 # self.datatime = None
670 697 # self.flagNoData = False
671 698 # self.expName = ''
672 699 # self.nChannels = None
673 700 # self.nSamples = None
674 701 # self.dataBlocksPerFile = None
675 702 # self.comments = ''
676 703 #
677 704
678 705
679 706 def getltctime(self):
680 707
681 708 if self.useLocalTime:
682 709 return self.utctime - self.timeZone*60
683 710
684 711 return self.utctime
685 712
686 713 def getDatatime(self):
687 714
688 715 datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
689 716 return datatime
690 717
691 718 def getTimeRange(self):
692 719
693 720 datatime = []
694 721
695 722 datatime.append(self.ltctime)
696 723 datatime.append(self.ltctime + self.timeInterval)
697 724
698 725 datatime = numpy.array(datatime)
699 726
700 727 return datatime
701 728
702 729 def getHeiRange(self):
703 730
704 731 heis = self.heightList
705 732
706 733 return heis
707 734
708 735 def isEmpty(self):
709 736
710 737 return self.flagNoData
711 738
712 739 def getNHeights(self):
713 740
714 741 return len(self.heightList)
715 742
716 743 def getNChannels(self):
717 744
718 745 return len(self.channelList)
719 746
720 747 def getChannelIndexList(self):
721 748
722 749 return range(self.nChannels)
723 750
724 751 def getNoise(self, type = 1):
725 752
726 753 self.noise = numpy.zeros(self.nChannels)
727 754
728 755 if type == 1:
729 756 noise = self.getNoisebyHildebrand()
730 757
731 758 if type == 2:
732 759 noise = self.getNoisebySort()
733 760
734 761 if type == 3:
735 762 noise = self.getNoisebyWindow()
736 763
737 764 return noise
738 765
766 def getTimeInterval(self):
767
768 raise ValueError, "This method is not implemented yet"
769
739 770 datatime = property(getDatatime, "I'm the 'datatime' property")
740 771 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
741 772 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
742 773 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
743 774 noise = property(getNoise, "I'm the 'nHeights' property.")
744 775 datatime = property(getDatatime, "I'm the 'datatime' property")
745 776 ltctime = property(getltctime, "I'm the 'ltctime' property")
777 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
746 778
747 779 class Correlation(JROData):
748 780
749 781 noise = None
750 782
751 783 SNR = None
752 784
753 785 pairsAutoCorr = None #Pairs of Autocorrelation
754 786
755 787 #--------------------------------------------------
756 788
757 789 data_corr = None
758 790
759 791 data_volt = None
760 792
761 793 lagT = None # each element value is a profileIndex
762 794
763 795 lagR = None # each element value is in km
764 796
765 797 pairsList = None
766 798
767 799 calculateVelocity = None
768 800
769 801 nPoints = None
770 802
771 803 nAvg = None
772 804
773 805 bufferSize = None
774 806
775 807 def __init__(self):
776 808 '''
777 809 Constructor
778 810 '''
779 811 self.radarControllerHeaderObj = RadarControllerHeader()
780 812
781 813 self.systemHeaderObj = SystemHeader()
782 814
783 815 self.type = "Correlation"
784 816
785 817 self.data = None
786 818
787 819 self.dtype = None
788 820
789 821 self.nProfiles = None
790 822
791 823 self.heightList = None
792 824
793 825 self.channelList = None
794 826
795 827 self.flagNoData = True
796 828
797 829 self.flagTimeBlock = False
798 830
799 831 self.utctime = None
800 832
801 833 self.timeZone = None
802 834
803 835 self.dstFlag = None
804 836
805 837 self.errorCount = None
806 838
807 839 self.blocksize = None
808 840
809 841 self.flagDecodeData = False #asumo q la data no esta decodificada
810 842
811 843 self.flagDeflipData = False #asumo q la data no esta sin flip
812 844
813 845 self.pairsList = None
814 846
815 847 self.nPoints = None
816 848
817 849 def getLagTRange(self, extrapoints=0):
818 850
819 851 lagTRange = self.lagT
820 852 diff = lagTRange[1] - lagTRange[0]
821 853 extra = numpy.arange(1,extrapoints + 1)*diff + lagTRange[-1]
822 854 lagTRange = numpy.hstack((lagTRange, extra))
823 855
824 856 return lagTRange
825 857
826 858 def getLagRRange(self, extrapoints=0):
827 859
828 860 return self.lagR
829 861
830 862 def getPairsList(self):
831 863
832 864 return self.pairsList
833 865
834 866 def getCalculateVelocity(self):
835 867
836 868 return self.calculateVelocity
837 869
838 870 def getNPoints(self):
839 871
840 872 return self.nPoints
841 873
842 874 def getNAvg(self):
843 875
844 876 return self.nAvg
845 877
846 878 def getBufferSize(self):
847 879
848 880 return self.bufferSize
849 881
850 882 def getPairsAutoCorr(self):
851 883 pairsList = self.pairsList
852 884 pairsAutoCorr = numpy.zeros(self.nChannels, dtype = 'int')*numpy.nan
853 885
854 886 for l in range(len(pairsList)):
855 887 firstChannel = pairsList[l][0]
856 888 secondChannel = pairsList[l][1]
857 889
858 890 #Obteniendo pares de Autocorrelacion
859 891 if firstChannel == secondChannel:
860 892 pairsAutoCorr[firstChannel] = int(l)
861 893
862 894 pairsAutoCorr = pairsAutoCorr.astype(int)
863 895
864 896 return pairsAutoCorr
865 897
866 898 def getNoise(self, mode = 2):
867 899
868 900 indR = numpy.where(self.lagR == 0)[0][0]
869 901 indT = numpy.where(self.lagT == 0)[0][0]
870 902
871 903 jspectra0 = self.data_corr[:,:,indR,:]
872 904 jspectra = copy.copy(jspectra0)
873 905
874 906 num_chan = jspectra.shape[0]
875 907 num_hei = jspectra.shape[2]
876 908
877 909 freq_dc = jspectra.shape[1]/2
878 910 ind_vel = numpy.array([-2,-1,1,2]) + freq_dc
879 911
880 912 if ind_vel[0]<0:
881 913 ind_vel[range(0,1)] = ind_vel[range(0,1)] + self.num_prof
882 914
883 915 if mode == 1:
884 916 jspectra[:,freq_dc,:] = (jspectra[:,ind_vel[1],:] + jspectra[:,ind_vel[2],:])/2 #CORRECCION
885 917
886 918 if mode == 2:
887 919
888 920 vel = numpy.array([-2,-1,1,2])
889 921 xx = numpy.zeros([4,4])
890 922
891 923 for fil in range(4):
892 924 xx[fil,:] = vel[fil]**numpy.asarray(range(4))
893 925
894 926 xx_inv = numpy.linalg.inv(xx)
895 927 xx_aux = xx_inv[0,:]
896 928
897 929 for ich in range(num_chan):
898 930 yy = jspectra[ich,ind_vel,:]
899 931 jspectra[ich,freq_dc,:] = numpy.dot(xx_aux,yy)
900 932
901 933 junkid = jspectra[ich,freq_dc,:]<=0
902 934 cjunkid = sum(junkid)
903 935
904 936 if cjunkid.any():
905 937 jspectra[ich,freq_dc,junkid.nonzero()] = (jspectra[ich,ind_vel[1],junkid] + jspectra[ich,ind_vel[2],junkid])/2
906 938
907 939 noise = jspectra0[:,freq_dc,:] - jspectra[:,freq_dc,:]
908 940
909 941 return noise
910 942
911 943 # pairsList = property(getPairsList, "I'm the 'pairsList' property.")
912 944 # nPoints = property(getNPoints, "I'm the 'nPoints' property.")
913 945 calculateVelocity = property(getCalculateVelocity, "I'm the 'calculateVelocity' property.")
914 946 nAvg = property(getNAvg, "I'm the 'nAvg' property.")
915 947 bufferSize = property(getBufferSize, "I'm the 'bufferSize' property.")
916 948
917 949
918 950 class Parameters(JROData):
919 951
920 952 #Information from previous data
921 953
922 954 inputUnit = None #Type of data to be processed
923 955
924 956 operation = None #Type of operation to parametrize
925 957
926 958 normFactor = None #Normalization Factor
927 959
928 960 groupList = None #List of Pairs, Groups, etc
929 961
930 962 #Parameters
931 963
932 964 data_param = None #Parameters obtained
933 965
934 966 data_pre = None #Data Pre Parametrization
935 967
936 968 data_SNR = None #Signal to Noise Ratio
937 969
938 970 heightRange = None #Heights
939 971
940 972 abscissaRange = None #Abscissa, can be velocities, lags or time
941 973
942 974 noise = None #Noise Potency
943 975
944 976 initUtcTime = None #Initial UTC time
945 977
946 978 paramInterval = None #Time interval to calculate Parameters in seconds
947 979
948 980 #Fitting
949 981
950 982 data_error = None #Error of the estimation
951 983
952 984 constants = None
953 985
954 986 library = None
955 987
956 988 #Output signal
957 989
958 990 outputInterval = None #Time interval to calculate output signal in seconds
959 991
960 992 data_output = None #Out signal
961 993
962 994
963 995
964 996 def __init__(self):
965 997 '''
966 998 Constructor
967 999 '''
968 1000 self.radarControllerHeaderObj = RadarControllerHeader()
969 1001
970 1002 self.systemHeaderObj = SystemHeader()
971 1003
972 1004 self.type = "Parameters"
973 1005
974 1006 def getTimeRange1(self):
975 1007
976 1008 datatime = []
977 1009
978 1010 datatime.append(self.initUtcTime)
979 1011 datatime.append(self.initUtcTime + self.outputInterval - 1)
980 1012
981 1013 datatime = numpy.array(datatime)
982 1014
983 1015 return datatime
General Comments 0
You need to be logged in to leave comments. Login now