##// END OF EJS Templates
schain
RSS
Error comparing "code == None", it was replaced by "code is None:"
Miguel Valdez -
r674:a8c22d5c048b
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1095 +1,1095
1 1 import numpy
2 2
3 3 from jroproc_base import ProcessingUnit, Operation
4 4 from schainpy.model.data.jrodata import Voltage
5 5
6 6 class VoltageProc(ProcessingUnit):
7 7
8 8
9 9 def __init__(self):
10 10
11 11 ProcessingUnit.__init__(self)
12 12
13 13 # self.objectDict = {}
14 14 self.dataOut = Voltage()
15 15 self.flip = 1
16 16
17 17 def run(self):
18 18 if self.dataIn.type == 'AMISR':
19 19 self.__updateObjFromAmisrInput()
20 20
21 21 if self.dataIn.type == 'Voltage':
22 22 self.dataOut.copy(self.dataIn)
23 23
24 24 # self.dataOut.copy(self.dataIn)
25 25
26 26 def __updateObjFromAmisrInput(self):
27 27
28 28 self.dataOut.timeZone = self.dataIn.timeZone
29 29 self.dataOut.dstFlag = self.dataIn.dstFlag
30 30 self.dataOut.errorCount = self.dataIn.errorCount
31 31 self.dataOut.useLocalTime = self.dataIn.useLocalTime
32 32
33 33 self.dataOut.flagNoData = self.dataIn.flagNoData
34 34 self.dataOut.data = self.dataIn.data
35 35 self.dataOut.utctime = self.dataIn.utctime
36 36 self.dataOut.channelList = self.dataIn.channelList
37 37 # self.dataOut.timeInterval = self.dataIn.timeInterval
38 38 self.dataOut.heightList = self.dataIn.heightList
39 39 self.dataOut.nProfiles = self.dataIn.nProfiles
40 40
41 41 self.dataOut.nCohInt = self.dataIn.nCohInt
42 42 self.dataOut.ippSeconds = self.dataIn.ippSeconds
43 43 self.dataOut.frequency = self.dataIn.frequency
44 44
45 45 self.dataOut.azimuth = self.dataIn.azimuth
46 46 self.dataOut.zenith = self.dataIn.zenith
47 47
48 48 self.dataOut.beam.codeList = self.dataIn.beam.codeList
49 49 self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
50 50 self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
51 51 #
52 52 # pass#
53 53 #
54 54 # def init(self):
55 55 #
56 56 #
57 57 # if self.dataIn.type == 'AMISR':
58 58 # self.__updateObjFromAmisrInput()
59 59 #
60 60 # if self.dataIn.type == 'Voltage':
61 61 # self.dataOut.copy(self.dataIn)
62 62 # # No necesita copiar en cada init() los atributos de dataIn
63 63 # # la copia deberia hacerse por cada nuevo bloque de datos
64 64
65 65 def selectChannels(self, channelList):
66 66
67 67 channelIndexList = []
68 68
69 69 for channel in channelList:
70 70 if channel not in self.dataOut.channelList:
71 71 raise ValueError, "Channel %d is not in %s" %(channel, str(self.dataOut.channelList))
72 72
73 73 index = self.dataOut.channelList.index(channel)
74 74 channelIndexList.append(index)
75 75
76 76 self.selectChannelsByIndex(channelIndexList)
77 77
78 78 def selectChannelsByIndex(self, channelIndexList):
79 79 """
80 80 Selecciona un bloque de datos en base a canales segun el channelIndexList
81 81
82 82 Input:
83 83 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
84 84
85 85 Affected:
86 86 self.dataOut.data
87 87 self.dataOut.channelIndexList
88 88 self.dataOut.nChannels
89 89 self.dataOut.m_ProcessingHeader.totalSpectra
90 90 self.dataOut.systemHeaderObj.numChannels
91 91 self.dataOut.m_ProcessingHeader.blockSize
92 92
93 93 Return:
94 94 None
95 95 """
96 96
97 97 for channelIndex in channelIndexList:
98 98 if channelIndex not in self.dataOut.channelIndexList:
99 99 print channelIndexList
100 100 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
101 101
102 102 # nChannels = len(channelIndexList)
103 103 if self.dataOut.flagDataAsBlock:
104 104 """
105 105 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
106 106 """
107 107 data = self.dataOut.data[channelIndexList,:,:]
108 108 else:
109 109 data = self.dataOut.data[channelIndexList,:]
110 110
111 111 self.dataOut.data = data
112 112 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
113 113 # self.dataOut.nChannels = nChannels
114 114
115 115 return 1
116 116
117 117 def selectHeights(self, minHei=None, maxHei=None):
118 118 """
119 119 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
120 120 minHei <= height <= maxHei
121 121
122 122 Input:
123 123 minHei : valor minimo de altura a considerar
124 124 maxHei : valor maximo de altura a considerar
125 125
126 126 Affected:
127 127 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
128 128
129 129 Return:
130 130 1 si el metodo se ejecuto con exito caso contrario devuelve 0
131 131 """
132 132
133 133 if minHei == None:
134 134 minHei = self.dataOut.heightList[0]
135 135
136 136 if maxHei == None:
137 137 maxHei = self.dataOut.heightList[-1]
138 138
139 139 if (minHei < self.dataOut.heightList[0]):
140 140 minHei = self.dataOut.heightList[0]
141 141 # raise ValueError, "height range [%d,%d] is not valid. Data height range is [%d, %d]" % (minHei,
142 142 # maxHei,
143 143 # self.dataOut.heightList[0],
144 144 # self.dataOut.heightList[-1])
145 145
146 146 if (maxHei > self.dataOut.heightList[-1]):
147 147 maxHei = self.dataOut.heightList[-1]
148 148 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
149 149
150 150 minIndex = 0
151 151 maxIndex = 0
152 152 heights = self.dataOut.heightList
153 153
154 154 inda = numpy.where(heights >= minHei)
155 155 indb = numpy.where(heights <= maxHei)
156 156
157 157 try:
158 158 minIndex = inda[0][0]
159 159 except:
160 160 minIndex = 0
161 161
162 162 try:
163 163 maxIndex = indb[0][-1]
164 164 except:
165 165 maxIndex = len(heights)
166 166
167 167 self.selectHeightsByIndex(minIndex, maxIndex)
168 168
169 169 return 1
170 170
171 171
172 172 def selectHeightsByIndex(self, minIndex, maxIndex):
173 173 """
174 174 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
175 175 minIndex <= index <= maxIndex
176 176
177 177 Input:
178 178 minIndex : valor de indice minimo de altura a considerar
179 179 maxIndex : valor de indice maximo de altura a considerar
180 180
181 181 Affected:
182 182 self.dataOut.data
183 183 self.dataOut.heightList
184 184
185 185 Return:
186 186 1 si el metodo se ejecuto con exito caso contrario devuelve 0
187 187 """
188 188
189 189 if (minIndex < 0) or (minIndex > maxIndex):
190 190 raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
191 191
192 192 if (maxIndex >= self.dataOut.nHeights):
193 193 maxIndex = self.dataOut.nHeights
194 194 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
195 195
196 196 # nHeights = maxIndex - minIndex + 1
197 197
198 198 #voltage
199 199 if self.dataOut.flagDataAsBlock:
200 200 """
201 201 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
202 202 """
203 203 data = self.dataOut.data[:,:, minIndex:maxIndex]
204 204 else:
205 205 data = self.dataOut.data[:, minIndex:maxIndex]
206 206
207 207 # firstHeight = self.dataOut.heightList[minIndex]
208 208
209 209 self.dataOut.data = data
210 210 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex]
211 211
212 212 if self.dataOut.nHeights <= 1:
213 213 raise ValueError, "selectHeights: Too few heights. Current number of heights is %d" %(self.dataOut.nHeights)
214 214
215 215 return 1
216 216
217 217
218 218 def filterByHeights(self, window):
219 219
220 220 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
221 221
222 222 if window == None:
223 223 window = (self.dataOut.radarControllerHeaderObj.txA/self.dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
224 224
225 225 newdelta = deltaHeight * window
226 226 r = self.dataOut.nHeights % window
227 227 newheights = (self.dataOut.nHeights-r)/window
228 228
229 229 if newheights <= 1:
230 230 raise ValueError, "filterByHeights: Too few heights. Current number of heights is %d and window is %d" %(self.dataOut.nHeights, window)
231 231
232 232 if self.dataOut.flagDataAsBlock:
233 233 """
234 234 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
235 235 """
236 236 buffer = self.dataOut.data[:, :, 0:self.dataOut.nHeights-r]
237 237 buffer = buffer.reshape(self.dataOut.nChannels,self.dataOut.nProfiles,self.dataOut.nHeights/window,window)
238 238 buffer = numpy.sum(buffer,3)
239 239
240 240 else:
241 241 buffer = self.dataOut.data[:,0:self.dataOut.nHeights-r]
242 242 buffer = buffer.reshape(self.dataOut.nChannels,self.dataOut.nHeights/window,window)
243 243 buffer = numpy.sum(buffer,2)
244 244
245 245 self.dataOut.data = buffer
246 246 self.dataOut.heightList = self.dataOut.heightList[0] + numpy.arange( newheights )*newdelta
247 247 self.dataOut.windowOfFilter = window
248 248
249 249 def setH0(self, h0, deltaHeight = None):
250 250
251 251 if not deltaHeight:
252 252 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
253 253
254 254 nHeights = self.dataOut.nHeights
255 255
256 256 newHeiRange = h0 + numpy.arange(nHeights)*deltaHeight
257 257
258 258 self.dataOut.heightList = newHeiRange
259 259
260 260 def deFlip(self, channelList = []):
261 261
262 262 data = self.dataOut.data.copy()
263 263
264 264 if self.dataOut.flagDataAsBlock:
265 265 flip = self.flip
266 266 profileList = range(self.dataOut.nProfiles)
267 267
268 268 if not channelList:
269 269 for thisProfile in profileList:
270 270 data[:,thisProfile,:] = data[:,thisProfile,:]*flip
271 271 flip *= -1.0
272 272 else:
273 273 for thisChannel in channelList:
274 274 if thisChannel not in self.dataOut.channelList:
275 275 continue
276 276
277 277 for thisProfile in profileList:
278 278 data[thisChannel,thisProfile,:] = data[thisChannel,thisProfile,:]*flip
279 279 flip *= -1.0
280 280
281 281 self.flip = flip
282 282
283 283 else:
284 284 if not channelList:
285 285 data[:,:] = data[:,:]*self.flip
286 286 else:
287 287 for thisChannel in channelList:
288 288 if thisChannel not in self.dataOut.channelList:
289 289 continue
290 290
291 291 data[thisChannel,:] = data[thisChannel,:]*self.flip
292 292
293 293 self.flip *= -1.
294 294
295 295 self.dataOut.data = data
296 296
297 297 def setRadarFrequency(self, frequency=None):
298 298
299 299 if frequency != None:
300 300 self.dataOut.frequency = frequency
301 301
302 302 return 1
303 303
304 304 class CohInt(Operation):
305 305
306 306 isConfig = False
307 307
308 308 __profIndex = 0
309 309 __withOverapping = False
310 310
311 311 __byTime = False
312 312 __initime = None
313 313 __lastdatatime = None
314 314 __integrationtime = None
315 315
316 316 __buffer = None
317 317
318 318 __dataReady = False
319 319
320 320 n = None
321 321
322 322
323 323 def __init__(self):
324 324
325 325 Operation.__init__(self)
326 326
327 327 # self.isConfig = False
328 328
329 329 def setup(self, n=None, timeInterval=None, overlapping=False, byblock=False):
330 330 """
331 331 Set the parameters of the integration class.
332 332
333 333 Inputs:
334 334
335 335 n : Number of coherent integrations
336 336 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
337 337 overlapping :
338 338
339 339 """
340 340
341 341 self.__initime = None
342 342 self.__lastdatatime = 0
343 343 self.__buffer = None
344 344 self.__dataReady = False
345 345 self.byblock = byblock
346 346
347 347 if n == None and timeInterval == None:
348 348 raise ValueError, "n or timeInterval should be specified ..."
349 349
350 350 if n != None:
351 351 self.n = n
352 352 self.__byTime = False
353 353 else:
354 354 self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
355 355 self.n = 9999
356 356 self.__byTime = True
357 357
358 358 if overlapping:
359 359 self.__withOverapping = True
360 360 self.__buffer = None
361 361 else:
362 362 self.__withOverapping = False
363 363 self.__buffer = 0
364 364
365 365 self.__profIndex = 0
366 366
367 367 def putData(self, data):
368 368
369 369 """
370 370 Add a profile to the __buffer and increase in one the __profileIndex
371 371
372 372 """
373 373
374 374 if not self.__withOverapping:
375 375 self.__buffer += data.copy()
376 376 self.__profIndex += 1
377 377 return
378 378
379 379 #Overlapping data
380 380 nChannels, nHeis = data.shape
381 381 data = numpy.reshape(data, (1, nChannels, nHeis))
382 382
383 383 #If the buffer is empty then it takes the data value
384 384 if self.__buffer is None:
385 385 self.__buffer = data
386 386 self.__profIndex += 1
387 387 return
388 388
389 389 #If the buffer length is lower than n then stakcing the data value
390 390 if self.__profIndex < self.n:
391 391 self.__buffer = numpy.vstack((self.__buffer, data))
392 392 self.__profIndex += 1
393 393 return
394 394
395 395 #If the buffer length is equal to n then replacing the last buffer value with the data value
396 396 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
397 397 self.__buffer[self.n-1] = data
398 398 self.__profIndex = self.n
399 399 return
400 400
401 401
402 402 def pushData(self):
403 403 """
404 404 Return the sum of the last profiles and the profiles used in the sum.
405 405
406 406 Affected:
407 407
408 408 self.__profileIndex
409 409
410 410 """
411 411
412 412 if not self.__withOverapping:
413 413 data = self.__buffer
414 414 n = self.__profIndex
415 415
416 416 self.__buffer = 0
417 417 self.__profIndex = 0
418 418
419 419 return data, n
420 420
421 421 #Integration with Overlapping
422 422 data = numpy.sum(self.__buffer, axis=0)
423 423 n = self.__profIndex
424 424
425 425 return data, n
426 426
427 427 def byProfiles(self, data):
428 428
429 429 self.__dataReady = False
430 430 avgdata = None
431 431 # n = None
432 432
433 433 self.putData(data)
434 434
435 435 if self.__profIndex == self.n:
436 436
437 437 avgdata, n = self.pushData()
438 438 self.__dataReady = True
439 439
440 440 return avgdata
441 441
442 442 def byTime(self, data, datatime):
443 443
444 444 self.__dataReady = False
445 445 avgdata = None
446 446 n = None
447 447
448 448 self.putData(data)
449 449
450 450 if (datatime - self.__initime) >= self.__integrationtime:
451 451 avgdata, n = self.pushData()
452 452 self.n = n
453 453 self.__dataReady = True
454 454
455 455 return avgdata
456 456
457 457 def integrate(self, data, datatime=None):
458 458
459 459 if self.__initime == None:
460 460 self.__initime = datatime
461 461
462 462 if self.__byTime:
463 463 avgdata = self.byTime(data, datatime)
464 464 else:
465 465 avgdata = self.byProfiles(data)
466 466
467 467
468 468 self.__lastdatatime = datatime
469 469
470 470 if avgdata is None:
471 471 return None, None
472 472
473 473 avgdatatime = self.__initime
474 474
475 475 deltatime = datatime -self.__lastdatatime
476 476
477 477 if not self.__withOverapping:
478 478 self.__initime = datatime
479 479 else:
480 480 self.__initime += deltatime
481 481
482 482 return avgdata, avgdatatime
483 483
484 484 def integrateByBlock(self, dataOut):
485 485
486 486 times = int(dataOut.data.shape[1]/self.n)
487 487 avgdata = numpy.zeros((dataOut.nChannels, times, dataOut.nHeights), dtype=numpy.complex)
488 488
489 489 id_min = 0
490 490 id_max = self.n
491 491
492 492 for i in range(times):
493 493 junk = dataOut.data[:,id_min:id_max,:]
494 494 avgdata[:,i,:] = junk.sum(axis=1)
495 495 id_min += self.n
496 496 id_max += self.n
497 497
498 498 timeInterval = dataOut.ippSeconds*self.n
499 499 avgdatatime = (times - 1) * timeInterval + dataOut.utctime
500 500 self.__dataReady = True
501 501 return avgdata, avgdatatime
502 502
503 503 def run(self, dataOut, **kwargs):
504 504
505 505 if not self.isConfig:
506 506 self.setup(**kwargs)
507 507 self.isConfig = True
508 508
509 509 if dataOut.flagDataAsBlock:
510 510 """
511 511 Si la data es leida por bloques, dimension = [nChannels, nProfiles, nHeis]
512 512 """
513 513 avgdata, avgdatatime = self.integrateByBlock(dataOut)
514 514 else:
515 515 avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
516 516
517 517 # dataOut.timeInterval *= n
518 518 dataOut.flagNoData = True
519 519
520 520 if self.__dataReady:
521 521 dataOut.data = avgdata
522 522 dataOut.nCohInt *= self.n
523 523 dataOut.utctime = avgdatatime
524 524 # dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
525 525 dataOut.flagNoData = False
526 526
527 527 class Decoder(Operation):
528 528
529 529 isConfig = False
530 530 __profIndex = 0
531 531
532 532 code = None
533 533
534 534 nCode = None
535 535 nBaud = None
536 536
537 537
538 538 def __init__(self):
539 539
540 540 Operation.__init__(self)
541 541
542 542 self.times = None
543 543 self.osamp = None
544 544 # self.__setValues = False
545 545 self.isConfig = False
546 546
547 547 def setup(self, code, osamp, dataOut):
548 548
549 549 self.__profIndex = 0
550 550
551 551 self.code = code
552 552
553 553 self.nCode = len(code)
554 554 self.nBaud = len(code[0])
555 555
556 556 if (osamp != None) and (osamp >1):
557 557 self.osamp = osamp
558 558 self.code = numpy.repeat(code, repeats=self.osamp, axis=1)
559 559 self.nBaud = self.nBaud*self.osamp
560 560
561 561 self.__nChannels = dataOut.nChannels
562 562 self.__nProfiles = dataOut.nProfiles
563 563 self.__nHeis = dataOut.nHeights
564 564
565 565 if self.__nHeis < self.nBaud:
566 566 print 'IOError: Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud)
567 567 raise IOError, 'Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud)
568 568
569 569 #Frequency
570 570 __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
571 571
572 572 __codeBuffer[:,0:self.nBaud] = self.code
573 573
574 574 self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
575 575
576 576 if dataOut.flagDataAsBlock:
577 577
578 578 self.ndatadec = self.__nHeis #- self.nBaud + 1
579 579
580 580 self.datadecTime = numpy.zeros((self.__nChannels, self.__nProfiles, self.ndatadec), dtype=numpy.complex)
581 581
582 582 else:
583 583
584 584 #Time
585 585 self.ndatadec = self.__nHeis #- self.nBaud + 1
586 586
587 587 self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
588 588
589 589 def __convolutionInFreq(self, data):
590 590
591 591 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
592 592
593 593 fft_data = numpy.fft.fft(data, axis=1)
594 594
595 595 conv = fft_data*fft_code
596 596
597 597 data = numpy.fft.ifft(conv,axis=1)
598 598
599 599 return data
600 600
601 601 def __convolutionInFreqOpt(self, data):
602 602
603 603 raise NotImplementedError
604 604
605 605 # fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
606 606 #
607 607 # data = cfunctions.decoder(fft_code, data)
608 608 #
609 609 # datadec = data#[:,:]
610 610 #
611 611 # return datadec
612 612
613 613 def __convolutionInTime(self, data):
614 614
615 615 code = self.code[self.__profIndex]
616 616
617 617 for i in range(self.__nChannels):
618 618 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='full')[self.nBaud-1:]
619 619
620 620 return self.datadecTime
621 621
622 622 def __convolutionByBlockInTime(self, data):
623 623
624 624 repetitions = self.__nProfiles / self.nCode
625 625
626 626 junk = numpy.lib.stride_tricks.as_strided(self.code, (repetitions, self.code.size), (0, self.code.itemsize))
627 627 junk = junk.flatten()
628 628 code_block = numpy.reshape(junk, (self.nCode*repetitions, self.nBaud))
629 629
630 630 for i in range(self.__nChannels):
631 631 for j in range(self.__nProfiles):
632 632 self.datadecTime[i,j,:] = numpy.correlate(data[i,j,:], code_block[j,:], mode='full')[self.nBaud-1:]
633 633
634 634 return self.datadecTime
635 635
636 636 def __convolutionByBlockInFreq(self, data):
637 637
638 638 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
639 639
640 640 fft_data = numpy.fft.fft(data, axis=2)
641 641
642 642 conv = fft_data*fft_code
643 643
644 644 data = numpy.fft.ifft(conv,axis=2)
645 645
646 646 return data
647 647
648 648 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0, osamp=None, times=None):
649 649
650 650 dataOut.flagNoData = True
651 651
652 652 if dataOut.flagDecodeData:
653 653 print "This data is already decoded, recoding again ..."
654 654
655 655 if not self.isConfig:
656 656
657 657 if code is None:
658 if not dataOut.code:
658 if dataOut.code is None:
659 659 print "Code is not defined"
660 660 raise ValueError, "Code could not be read from %s object. Enter a value in Code parameter" %dataOut.type
661 661
662 662 code = dataOut.code
663 663 else:
664 664 code = numpy.array(code).reshape(nCode,nBaud)
665 665
666 666 self.setup(code, osamp, dataOut)
667 667
668 668 self.isConfig = True
669 669
670 670 if self.code is None:
671 671 print "Fail decoding: Code is not defined."
672 672 return
673 673
674 674 datadec = None
675 675
676 676 if dataOut.flagDataAsBlock:
677 677 """
678 678 Decoding when data have been read as block,
679 679 """
680 680 if mode == 0:
681 681 datadec = self.__convolutionByBlockInTime(dataOut.data)
682 682 if mode == 1:
683 683 datadec = self.__convolutionByBlockInFreq(dataOut.data)
684 684 else:
685 685 """
686 686 Decoding when data have been read profile by profile
687 687 """
688 688 if mode == 0:
689 689 datadec = self.__convolutionInTime(dataOut.data)
690 690
691 691 if mode == 1:
692 692 datadec = self.__convolutionInFreq(dataOut.data)
693 693
694 694 if mode == 2:
695 695 datadec = self.__convolutionInFreqOpt(dataOut.data)
696 696
697 697 if datadec is None:
698 698 raise ValueError, "Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode
699 699
700 700 dataOut.code = self.code
701 701 dataOut.nCode = self.nCode
702 702 dataOut.nBaud = self.nBaud
703 703
704 704 dataOut.data = datadec
705 705
706 706 dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
707 707
708 708 dataOut.flagDecodeData = True #asumo q la data esta decodificada
709 709
710 710 if self.__profIndex == self.nCode-1:
711 711 self.__profIndex = 0
712 712 return 1
713 713
714 714 self.__profIndex += 1
715 715
716 716 dataOut.flagNoData = False
717 717
718 718 return 1
719 719 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
720 720
721 721
722 722 class ProfileConcat(Operation):
723 723
724 724 isConfig = False
725 725 buffer = None
726 726
727 727 def __init__(self):
728 728
729 729 Operation.__init__(self)
730 730 self.profileIndex = 0
731 731
732 732 def reset(self):
733 733 self.buffer = numpy.zeros_like(self.buffer)
734 734 self.start_index = 0
735 735 self.times = 1
736 736
737 737 def setup(self, data, m, n=1):
738 738 self.buffer = numpy.zeros((data.shape[0],data.shape[1]*m),dtype=type(data[0,0]))
739 739 self.nHeights = data.nHeights
740 740 self.start_index = 0
741 741 self.times = 1
742 742
743 743 def concat(self, data):
744 744
745 745 self.buffer[:,self.start_index:self.profiles*self.times] = data.copy()
746 746 self.start_index = self.start_index + self.nHeights
747 747
748 748 def run(self, dataOut, m):
749 749
750 750 dataOut.flagNoData = True
751 751
752 752 if not self.isConfig:
753 753 self.setup(dataOut.data, m, 1)
754 754 self.isConfig = True
755 755
756 756 if dataOut.flagDataAsBlock:
757 757
758 758 raise ValueError, "ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False"
759 759
760 760 else:
761 761 self.concat(dataOut.data)
762 762 self.times += 1
763 763 if self.times > m:
764 764 dataOut.data = self.buffer
765 765 self.reset()
766 766 dataOut.flagNoData = False
767 767 # se deben actualizar mas propiedades del header y del objeto dataOut, por ejemplo, las alturas
768 768 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
769 769 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * m
770 770 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
771 771 dataOut.ippSeconds *= m
772 772
773 773 class ProfileSelector(Operation):
774 774
775 775 profileIndex = None
776 776 # Tamanho total de los perfiles
777 777 nProfiles = None
778 778
779 779 def __init__(self):
780 780
781 781 Operation.__init__(self)
782 782 self.profileIndex = 0
783 783
784 784 def incIndex(self):
785 785
786 786 self.profileIndex += 1
787 787
788 788 if self.profileIndex >= self.nProfiles:
789 789 self.profileIndex = 0
790 790
791 791 def isThisProfileInRange(self, profileIndex, minIndex, maxIndex):
792 792
793 793 if profileIndex < minIndex:
794 794 return False
795 795
796 796 if profileIndex > maxIndex:
797 797 return False
798 798
799 799 return True
800 800
801 801 def isThisProfileInList(self, profileIndex, profileList):
802 802
803 803 if profileIndex not in profileList:
804 804 return False
805 805
806 806 return True
807 807
808 808 def run(self, dataOut, profileList=None, profileRangeList=None, beam=None, byblock=False, rangeList = None, nProfiles=None):
809 809
810 810 """
811 811 ProfileSelector:
812 812
813 813 Inputs:
814 814 profileList : Index of profiles selected. Example: profileList = (0,1,2,7,8)
815 815
816 816 profileRangeList : Minimum and maximum profile indexes. Example: profileRangeList = (4, 30)
817 817
818 818 rangeList : List of profile ranges. Example: rangeList = ((4, 30), (32, 64), (128, 256))
819 819
820 820 """
821 821
822 822 dataOut.flagNoData = True
823 823
824 824 if dataOut.flagDataAsBlock:
825 825 """
826 826 data dimension = [nChannels, nProfiles, nHeis]
827 827 """
828 828 if profileList != None:
829 829 dataOut.data = dataOut.data[:,profileList,:]
830 830 dataOut.nProfiles = len(profileList)
831 831 dataOut.profileIndex = dataOut.nProfiles - 1
832 832
833 833 if profileRangeList != None:
834 834 minIndex = profileRangeList[0]
835 835 maxIndex = profileRangeList[1]
836 836
837 837 dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
838 838 dataOut.nProfiles = maxIndex - minIndex + 1
839 839 dataOut.profileIndex = dataOut.nProfiles - 1
840 840
841 841 if rangeList != None:
842 842 raise ValueError, "Profile Selector: Invalid argument rangeList. Not implemented for getByBlock yet"
843 843
844 844 dataOut.flagNoData = False
845 845
846 846 return True
847 847
848 848 """
849 849 data dimension = [nChannels, nHeis]
850 850 """
851 851
852 852 if nProfiles:
853 853 self.nProfiles = nProfiles
854 854 else:
855 855 self.nProfiles = dataOut.nProfiles
856 856
857 857 if profileList != None:
858 858
859 859 dataOut.nProfiles = len(profileList)
860 860
861 861 if self.isThisProfileInList(dataOut.profileIndex, profileList):
862 862 dataOut.flagNoData = False
863 863 dataOut.profileIndex = self.profileIndex
864 864
865 865 self.incIndex()
866 866 return True
867 867
868 868 if profileRangeList != None:
869 869
870 870 minIndex = profileRangeList[0]
871 871 maxIndex = profileRangeList[1]
872 872
873 873 dataOut.nProfiles = maxIndex - minIndex + 1
874 874
875 875 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
876 876 dataOut.flagNoData = False
877 877 dataOut.profileIndex = self.profileIndex
878 878
879 879 self.incIndex()
880 880 return True
881 881
882 882 if rangeList != None:
883 883
884 884 nProfiles = 0
885 885
886 886 for thisRange in rangeList:
887 887 minIndex = thisRange[0]
888 888 maxIndex = thisRange[1]
889 889
890 890 nProfiles += maxIndex - minIndex + 1
891 891
892 892 dataOut.nProfiles = nProfiles
893 893
894 894 for thisRange in rangeList:
895 895
896 896 minIndex = thisRange[0]
897 897 maxIndex = thisRange[1]
898 898
899 899 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
900 900
901 901 # print "profileIndex = ", dataOut.profileIndex
902 902
903 903 dataOut.flagNoData = False
904 904 dataOut.profileIndex = self.profileIndex
905 905
906 906 self.incIndex()
907 907 break
908 908 return True
909 909
910 910
911 911 if beam != None: #beam is only for AMISR data
912 912 if self.isThisProfileInList(dataOut.profileIndex, dataOut.beamRangeDict[beam]):
913 913 dataOut.flagNoData = False
914 914 dataOut.profileIndex = self.profileIndex
915 915
916 916 self.incIndex()
917 917
918 918 return True
919 919
920 920 raise ValueError, "ProfileSelector needs profileList, profileRangeList or rangeList parameter"
921 921
922 922 return False
923 923
924 924
925 925
926 926 class Reshaper(Operation):
927 927
928 928 def __init__(self):
929 929
930 930 Operation.__init__(self)
931 931 self.updateNewHeights = True
932 932
933 933 def run(self, dataOut, shape):
934 934
935 935 if not dataOut.flagDataAsBlock:
936 936 raise ValueError, "Reshaper can only be used when voltage have been read as Block, getBlock = True"
937 937
938 938 if len(shape) != 3:
939 939 raise ValueError, "shape len should be equal to 3, (nChannels, nProfiles, nHeis)"
940 940
941 941 shape_tuple = tuple(shape)
942 942 dataOut.data = numpy.reshape(dataOut.data, shape_tuple)
943 943 dataOut.flagNoData = False
944 944
945 945 if self.updateNewHeights:
946 946
947 947 old_nheights = dataOut.nHeights
948 948 new_nheights = dataOut.data.shape[2]
949 949 factor = 1.0*new_nheights / old_nheights
950 950
951 951 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
952 952
953 953 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * factor
954 954
955 955 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
956 956
957 957 dataOut.nProfiles = dataOut.data.shape[1]
958 958
959 959 dataOut.ippSeconds *= factor
960 960 #
961 961 # import collections
962 962 # from scipy.stats import mode
963 963 #
964 964 # class Synchronize(Operation):
965 965 #
966 966 # isConfig = False
967 967 # __profIndex = 0
968 968 #
969 969 # def __init__(self):
970 970 #
971 971 # Operation.__init__(self)
972 972 # # self.isConfig = False
973 973 # self.__powBuffer = None
974 974 # self.__startIndex = 0
975 975 # self.__pulseFound = False
976 976 #
977 977 # def __findTxPulse(self, dataOut, channel=0, pulse_with = None):
978 978 #
979 979 # #Read data
980 980 #
981 981 # powerdB = dataOut.getPower(channel = channel)
982 982 # noisedB = dataOut.getNoise(channel = channel)[0]
983 983 #
984 984 # self.__powBuffer.extend(powerdB.flatten())
985 985 #
986 986 # dataArray = numpy.array(self.__powBuffer)
987 987 #
988 988 # filteredPower = numpy.correlate(dataArray, dataArray[0:self.__nSamples], "same")
989 989 #
990 990 # maxValue = numpy.nanmax(filteredPower)
991 991 #
992 992 # if maxValue < noisedB + 10:
993 993 # #No se encuentra ningun pulso de transmision
994 994 # return None
995 995 #
996 996 # maxValuesIndex = numpy.where(filteredPower > maxValue - 0.1*abs(maxValue))[0]
997 997 #
998 998 # if len(maxValuesIndex) < 2:
999 999 # #Solo se encontro un solo pulso de transmision de un baudio, esperando por el siguiente TX
1000 1000 # return None
1001 1001 #
1002 1002 # phasedMaxValuesIndex = maxValuesIndex - self.__nSamples
1003 1003 #
1004 1004 # #Seleccionar solo valores con un espaciamiento de nSamples
1005 1005 # pulseIndex = numpy.intersect1d(maxValuesIndex, phasedMaxValuesIndex)
1006 1006 #
1007 1007 # if len(pulseIndex) < 2:
1008 1008 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1009 1009 # return None
1010 1010 #
1011 1011 # spacing = pulseIndex[1:] - pulseIndex[:-1]
1012 1012 #
1013 1013 # #remover senales que se distancien menos de 10 unidades o muestras
1014 1014 # #(No deberian existir IPP menor a 10 unidades)
1015 1015 #
1016 1016 # realIndex = numpy.where(spacing > 10 )[0]
1017 1017 #
1018 1018 # if len(realIndex) < 2:
1019 1019 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1020 1020 # return None
1021 1021 #
1022 1022 # #Eliminar pulsos anchos (deja solo la diferencia entre IPPs)
1023 1023 # realPulseIndex = pulseIndex[realIndex]
1024 1024 #
1025 1025 # period = mode(realPulseIndex[1:] - realPulseIndex[:-1])[0][0]
1026 1026 #
1027 1027 # print "IPP = %d samples" %period
1028 1028 #
1029 1029 # self.__newNSamples = dataOut.nHeights #int(period)
1030 1030 # self.__startIndex = int(realPulseIndex[0])
1031 1031 #
1032 1032 # return 1
1033 1033 #
1034 1034 #
1035 1035 # def setup(self, nSamples, nChannels, buffer_size = 4):
1036 1036 #
1037 1037 # self.__powBuffer = collections.deque(numpy.zeros( buffer_size*nSamples,dtype=numpy.float),
1038 1038 # maxlen = buffer_size*nSamples)
1039 1039 #
1040 1040 # bufferList = []
1041 1041 #
1042 1042 # for i in range(nChannels):
1043 1043 # bufferByChannel = collections.deque(numpy.zeros( buffer_size*nSamples, dtype=numpy.complex) + numpy.NAN,
1044 1044 # maxlen = buffer_size*nSamples)
1045 1045 #
1046 1046 # bufferList.append(bufferByChannel)
1047 1047 #
1048 1048 # self.__nSamples = nSamples
1049 1049 # self.__nChannels = nChannels
1050 1050 # self.__bufferList = bufferList
1051 1051 #
1052 1052 # def run(self, dataOut, channel = 0):
1053 1053 #
1054 1054 # if not self.isConfig:
1055 1055 # nSamples = dataOut.nHeights
1056 1056 # nChannels = dataOut.nChannels
1057 1057 # self.setup(nSamples, nChannels)
1058 1058 # self.isConfig = True
1059 1059 #
1060 1060 # #Append new data to internal buffer
1061 1061 # for thisChannel in range(self.__nChannels):
1062 1062 # bufferByChannel = self.__bufferList[thisChannel]
1063 1063 # bufferByChannel.extend(dataOut.data[thisChannel])
1064 1064 #
1065 1065 # if self.__pulseFound:
1066 1066 # self.__startIndex -= self.__nSamples
1067 1067 #
1068 1068 # #Finding Tx Pulse
1069 1069 # if not self.__pulseFound:
1070 1070 # indexFound = self.__findTxPulse(dataOut, channel)
1071 1071 #
1072 1072 # if indexFound == None:
1073 1073 # dataOut.flagNoData = True
1074 1074 # return
1075 1075 #
1076 1076 # self.__arrayBuffer = numpy.zeros((self.__nChannels, self.__newNSamples), dtype = numpy.complex)
1077 1077 # self.__pulseFound = True
1078 1078 # self.__startIndex = indexFound
1079 1079 #
1080 1080 # #If pulse was found ...
1081 1081 # for thisChannel in range(self.__nChannels):
1082 1082 # bufferByChannel = self.__bufferList[thisChannel]
1083 1083 # #print self.__startIndex
1084 1084 # x = numpy.array(bufferByChannel)
1085 1085 # self.__arrayBuffer[thisChannel] = x[self.__startIndex:self.__startIndex+self.__newNSamples]
1086 1086 #
1087 1087 # deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1088 1088 # dataOut.heightList = numpy.arange(self.__newNSamples)*deltaHeight
1089 1089 # # dataOut.ippSeconds = (self.__newNSamples / deltaHeight)/1e6
1090 1090 #
1091 1091 # dataOut.data = self.__arrayBuffer
1092 1092 #
1093 1093 # self.__startIndex += self.__newNSamples
1094 1094 #
1095 1095 # return No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now