##// END OF EJS Templates
schain-jc
RSS
SpectraProcessor.py:...
Victor Sarmiento -
r85:2d16b3b6fea5
parent child
Show More
Show file before | Show file after | Hide comments
@@ -20,28 +20,22 class SpectraProcessor:
20 classdocs
20 classdocs
21 '''
21 '''
22
22
23 def __init__(self, spectraInObj, spectraOutObj=None, npts = None):
23 def __init__(self, dataInObj, dataOutObj=None):
24 '''
24 '''
25 Constructor
25 Constructor
26 '''
26 '''
27 self.spectraInObj = spectraInObj
27 self.dataInObj = dataInObj
28
28
29 if spectraOutObj == None:
29 if dataOutObj == None:
30 self.spectraOutObj = Spectra()
30 self.dataOutObj = Spectra()
31 else:
31 else:
32 self.spectraOutObj = spectraOutObj
32 self.dataOutObj = dataOutObj
33
34
33
35 self.integratorIndex = None
34 self.integratorIndex = None
36 self.decoderIndex = None
35 self.decoderIndex = None
37 self.writerIndex = None
36 self.writerIndex = None
38 self.plotterIndex = None
37 self.plotterIndex = None
39
38
40 if npts != None:
41 self.spectraOutObj.nPoints = npts
42
43 self.npts = self.spectraOutObj.nPoints
44
45 self.integratorList = []
39 self.integratorList = []
46 self.decoderList = []
40 self.decoderList = []
47 self.writerList = []
41 self.writerList = []
@@ -50,54 +44,144 class SpectraProcessor:
50 self.buffer = None
44 self.buffer = None
51 self.ptsId = 0
45 self.ptsId = 0
52
46
53 def init(self):
47 def init(self, nFFTPoints, pairList=None):
48
54 self.integratorIndex = 0
49 self.integratorIndex = 0
55 self.decoderIndex = 0
50 self.decoderIndex = 0
56 self.writerIndex = 0
51 self.writerIndex = 0
57 self.plotterIndex = 0
52 self.plotterIndex = 0
58
53
59 if not( isinstance(self.spectraInObj, Spectra) ):
54 if nFFTPoints == None:
60 self.getFft()
55 nFFTPoints = self.dataOutObj.nPoints
56
57 self.nFFTPoints = nFFTPoints
58 self.pairList = pairList
59
60 if not( isinstance(self.dataInObj, Spectra) ):
61 self.__getFft()
61 else:
62 else:
62 self.spectraOutObj.copy(self.spectraInObj)
63 self.dataOutObj.copy(self.dataInObj)
63
64
64
65
65 def getFft(self):
66 def __getFft(self):
67 """
68 Convierte valores de Voltaje a Spectra
69
70 Affected:
71 self.dataOutObj.data_spc
72 self.dataOutObj.data_cspc
73 self.dataOutObj.data_dc
74 self.dataOutObj.heightList
75 self.dataOutObj.m_BasicHeader
76 self.dataOutObj.m_ProcessingHeader
77 self.dataOutObj.m_RadarControllerHeader
78 self.dataOutObj.m_SystemHeader
79 self.ptsId
80 self.buffer
81 self.dataOutObj.flagNoData
82 self.dataOutObj.dataType
83 self.dataOutObj.nPairs
84 self.dataOutObj.nChannels
85 self.dataOutObj.nProfiles
86 self.dataOutObj.m_SystemHeader.numChannels
87 self.dataOutObj.m_ProcessingHeader.totalSpectra
88 self.dataOutObj.m_ProcessingHeader.profilesPerBlock
89 self.dataOutObj.m_ProcessingHeader.numHeights
90 self.dataOutObj.m_ProcessingHeader.spectraComb
91 self.dataOutObj.m_ProcessingHeader.shif_fft
92 """
93 blocksize = 0
94 npoints = self.nFFTPoints
95 nchannels, nheis = self.dataInObj.data.shape
66
96
67 if self.buffer == None:
97 if self.buffer == None:
68 nheis = self.spectraInObj.data.shape[1]
98 self.buffer = numpy.zeros((nchannels, npoints, nheis), dtype='complex')
69 nchannel = self.spectraInObj.data.shape[0]
70 npoints = self.spectraOutObj.nPoints
71 self.buffer = numpy.zeros((nchannel,npoints,nheis),dtype='complex')
72
99
73 self.buffer[:,self.ptsId,:] = self.spectraInObj.data
100 self.buffer[:,self.ptsId,:] = self.dataInObj.data
74 self.ptsId += 1
101 self.ptsId += 1
75 self.spectraOutObj.flagNoData = True
76 if self.ptsId >= self.spectraOutObj.nPoints:
77 data_spc = numpy.fft.fft(self.buffer,axis=1)
78 data_spc = numpy.fft.fftshift(data_spc,axes=1)
79 self.ptsId = 0
80 self.buffer = None
81
102
82 #calculo de self-spectra
103 if self.ptsId < self.dataOutObj.nPoints:
83 self.spectraOutObj.data_spc = numpy.abs(data_spc * numpy.conjugate(data_spc))
104 self.dataOutObj.flagNoData = True
105 return
84
106
107 fft_volt = numpy.fft.fft(self.buffer,axis=1)
108 dc = fft_volt[:,0,:]
109
110 #calculo de self-spectra
111 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
112 spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))
113
114 blocksize += dc.size
115 blocksize += spc.size
116
117 cspc = None
118 npair = 0
119 if self.pairList != None:
85 #calculo de cross-spectra
120 #calculo de cross-spectra
86 #self.m_Spectra.data_cspc = self.__data_cspc
121 npairs = len(self.pairList)
122 cspc = numpy.zeros((npairs, npoints, nheis), dtype='complex')
123 for pair in self.pairList:
124 cspc[npair,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
125 npair += 1
126 blocksize += cspc.size
127
128 self.dataOutObj.data_spc = spc
129 self.dataOutObj.data_cspc = cspc
130 self.dataOutObj.data_dc = dc
131
132 self.ptsId = 0
133 self.buffer = None
134 self.dataOutObj.flagNoData = False
135
136 self.dataOutObj.heightList = self.dataInObj.heightList
137 self.dataOutObj.channelList = self.dataInObj.channelList
138 self.dataOutObj.m_BasicHeader = self.dataInObj.m_BasicHeader.copy()
139 self.dataOutObj.m_ProcessingHeader = self.dataInObj.m_ProcessingHeader.copy()
140 self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
141 self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
142
143 self.dataOutObj.dataType = self.dataInObj.dataType
144 self.dataOutObj.nPairs = npair
145 self.dataOutObj.nChannels = nchannels
146 self.dataOutObj.nProfiles = npoints
147 self.dataOutObj.nHeights = nheis
148 self.dataOutObj.nPoints = npoints
149 #self.dataOutObj.data = None
150
151 self.dataOutObj.m_SystemHeader.numChannels = nchannels
152 self.dataOutObj.m_SystemHeader.nProfiles = npoints
153
154 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
155 self.dataOutObj.m_ProcessingHeader.totalSpectra = nchannels + npair
156 self.dataOutObj.m_ProcessingHeader.profilesPerBlock = npoints
157 self.dataOutObj.m_ProcessingHeader.numHeights = nheis
158 self.dataOutObj.m_ProcessingHeader.shif_fft = True
159
160 spectraComb = numpy.zeros( (nchannels+npair)*2,numpy.dtype('u1'))
161 k = 0
162 for i in range( 0,nchannels*2,2 ):
163 spectraComb[i] = k
164 spectraComb[i+1] = k
165 k += 1
166
167 k *= 2
168
169 if self.pairList != None:
87
170
88 #escribiendo dc
171 for pair in self.pairList:
89 #self.m_Spectra.data_dc = self.__data_dc
172 spectraComb[k] = pair[0]
173 spectraComb[k+1] = pair[1]
174 k += 2
90
175
91 self.spectraOutObj.flagNoData = False
176 self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
177
178 #self.selectHeightsByIndex( 0,10)
179 #self.selectHeightsByValue( 120,200 )
180 #self.selectChannels((2,4,5), self.pairList)
181
92
182
93 self.spectraOutObj.heights = self.spectraInObj.heights
94 self.spectraOutObj.m_BasicHeader = self.spectraInObj.m_BasicHeader.copy()
95 self.spectraOutObj.m_ProcessingHeader = self.spectraInObj.m_ProcessingHeader.copy()
96 self.spectraOutObj.m_RadarControllerHeader = self.spectraInObj.m_RadarControllerHeader.copy()
97 self.spectraOutObj.m_SystemHeader = self.spectraInObj.m_SystemHeader.copy()
98
99 def addWriter(self,wrpath):
183 def addWriter(self,wrpath):
100 objWriter = SpectraWriter(self.spectraOutObj)
184 objWriter = SpectraWriter(self.dataOutObj)
101 objWriter.setup(wrpath)
185 objWriter.setup(wrpath)
102 self.writerList.append(objWriter)
186 self.writerList.append(objWriter)
103
187
@@ -107,7 +191,7 class SpectraProcessor:
107 if index==None:
191 if index==None:
108 index = self.plotterIndex
192 index = self.plotterIndex
109
193
110 plotObj = Spectrum(self.spectraOutObj, index)
194 plotObj = Spectrum(self.dataOutObj, index)
111 self.plotterList.append(plotObj)
195 self.plotterList.append(plotObj)
112
196
113
197
@@ -117,8 +201,8 class SpectraProcessor:
117 self.integratorList.append(objIncohInt)
201 self.integratorList.append(objIncohInt)
118
202
119
203
120 def writeData(self):
204 def writeData(self, wrpath):
121 if self.voltageOutObj.flagNoData:
205 if self.dataOutObj.flagNoData:
122 return 0
206 return 0
123
207
124 if len(self.writerList) <= self.writerIndex:
208 if len(self.writerList) <= self.writerIndex:
@@ -129,7 +213,7 class SpectraProcessor:
129 self.writerIndex += 1
213 self.writerIndex += 1
130
214
131 def plotData(self,xmin=None, xmax=None, ymin=None, ymax=None, winTitle='', index=None):
215 def plotData(self,xmin=None, xmax=None, ymin=None, ymax=None, winTitle='', index=None):
132 if self.spectraOutObj.flagNoData:
216 if self.dataOutObj.flagNoData:
133 return 0
217 return 0
134
218
135 if len(self.plotterList) <= self.plotterIndex:
219 if len(self.plotterList) <= self.plotterIndex:
@@ -140,25 +224,254 class SpectraProcessor:
140 self.plotterIndex += 1
224 self.plotterIndex += 1
141
225
142 def integrator(self, N):
226 def integrator(self, N):
143 if self.spectraOutObj.flagNoData:
227 if self.dataOutObj.flagNoData:
144 return 0
228 return 0
145
229
146 if len(self.integratorList) <= self.integratorIndex:
230 if len(self.integratorList) <= self.integratorIndex:
147 self.addIntegrator(N)
231 self.addIntegrator(N)
148
232
149 myCohIntObj = self.integratorList[self.integratorIndex]
233 myCohIntObj = self.integratorList[self.integratorIndex]
150 myCohIntObj.exe(self.spectraOutObj.data_spc)
234 myCohIntObj.exe(self.dataOutObj.data_spc)
151
235
152 if myCohIntObj.flag:
236 if myCohIntObj.flag:
153 self.spectraOutObj.data_spc = myCohIntObj.data
237 self.dataOutObj.data_spc = myCohIntObj.data
154 self.spectraOutObj.m_ProcessingHeader.incoherentInt *= N
238 self.dataOutObj.m_ProcessingHeader.incoherentInt *= N
155 self.spectraOutObj.flagNoData = False
239 self.dataOutObj.flagNoData = False
156
240
157 else:
241 else:
158 self.spectraOutObj.flagNoData = True
242 self.dataOutObj.flagNoData = True
159
243
160 self.integratorIndex += 1
244 self.integratorIndex += 1
245
246 def removeDC(self, type):
247
248 if self.dataOutObj.flagNoData:
249 return 0
250 pass
251
252 def removeInterference(self):
253
254 if self.dataOutObj.flagNoData:
255 return 0
256 pass
257
258 def removeSatellites(self):
259
260 if self.dataOutObj.flagNoData:
261 return 0
262 pass
263
264 def selectChannels(self, channelList, pairList=None):
265 """
266 Selecciona un bloque de datos en base a canales y pares segun el channelList y el pairList
267
268 Input:
269 channelList : lista sencilla de canales a seleccionar por ej. (2,3,7)
270 pairList : tupla de pares que se desea selecionar por ej. ( (0,1), (0,2) )
271
272 Affected:
273 self.dataOutObj.data_spc
274 self.dataOutObj.data_cspc
275 self.dataOutObj.data_dc
276 self.dataOutObj.nChannels
277 self.dataOutObj.nPairs
278 self.dataOutObj.m_ProcessingHeader.spectraComb
279 self.dataOutObj.m_SystemHeader.numChannels
280
281 Return:
282 None
283 """
284
285 if self.dataOutObj.flagNoData:
286 return 0
287
288 nchannels = 0
289 npairs = 0
290 profiles = self.dataOutObj.nProfiles
291 dataType = self.dataOutObj.dataType
292 heights = self.dataOutObj.m_ProcessingHeader.numHeights
293 blocksize = 0
294
295 #self spectra
296 nchannels = len(channelList)
297 spc = numpy.zeros( (nchannels,profiles,heights), dataType[0] )
161
298
299 for index, channel in enumerate(channelList):
300 spc[index,:,:] = self.dataOutObj.data_spc[channel,:,:]
301
302 #DC channel
303 dc = numpy.zeros( (nchannels,heights), dtype='complex' )
304 for index, channel in enumerate(channelList):
305 dc[index,:] = self.dataOutObj.data_dc[channel,:]
306
307 blocksize += dc.size
308 blocksize += spc.size
309
310 npairs = 0
311 cspc = None
312
313 if pairList == None:
314 pairList = self.pairList
315
316 if pairList != None:
317 #cross spectra
318 npairs = len(pairList)
319 cspc = numpy.zeros( (npairs,profiles,heights), dtype='complex' )
320
321 spectraComb = self.dataOutObj.m_ProcessingHeader.spectraComb
322 totalSpectra = len(spectraComb)
323 nchan = self.dataOutObj.nChannels
324 indexList = []
325
326 for pair in pairList: #busco el par en la lista de pares del Spectra Combinations
327 for index in range(0,totalSpectra,2):
328 if pair[0] == spectraComb[index] and pair[1] == spectraComb[index+1]:
329 indexList.append( index/2 - nchan )
330
331 for index, pair in enumerate(indexList):
332 cspc[index,:,:] = self.dataOutObj.data_cspc[pair,:,:]
333 blocksize += cspc.size
334
335 else:
336 pairList = self.pairList
337 cspc = self.dataOutObj.data_cspc
338 if cspc != None:
339 blocksize += cspc.size
340
341 spectraComb = numpy.zeros( (nchannels+npairs)*2,numpy.dtype('u1'))
342 i = 0
343 for val in channelList:
344 spectraComb[i] = val
345 spectraComb[i+1] = val
346 i += 2
347
348 if pairList != None:
349 for pair in pairList:
350 spectraComb[i] = pair[0]
351 spectraComb[i+1] = pair[1]
352 i += 2
353
354 self.dataOutObj.data_spc = spc
355 self.dataOutObj.data_cspc = cspc
356 self.dataOutObj.data_dc = dc
357 self.dataOutObj.nChannels = nchannels
358 self.dataOutObj.nPairs = npairs
359
360 self.dataOutObj.channelList = channelList
361
362 self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
363 self.dataOutObj.m_ProcessingHeader.totalSpectra = nchannels + npairs
364 self.dataOutObj.m_SystemHeader.numChannels = nchannels
365 self.dataOutObj.nChannels = nchannels
366 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
367
368
369 def selectHeightsByValue(self, minHei, maxHei):
370 """
371 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
372 minHei <= height <= maxHei
373
374 Input:
375 minHei : valor minimo de altura a considerar
376 maxHei : valor maximo de altura a considerar
377
378 Affected:
379 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
380
381 Return:
382 None
383 """
384
385 if self.dataOutObj.flagNoData:
386 return 0
387
388 minIndex = 0
389 maxIndex = 0
390 data = self.dataOutObj.heightList
391
392 for i,val in enumerate(data):
393 if val < minHei:
394 continue
395 else:
396 minIndex = i;
397 break
398
399 for i,val in enumerate(data):
400 if val <= maxHei:
401 maxIndex = i;
402 else:
403 break
404
405 self.selectHeightsByIndex(minIndex, maxIndex)
406
407
408 def selectHeightsByIndex(self, minIndex, maxIndex):
409 """
410 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
411 minIndex <= index <= maxIndex
412
413 Input:
414 minIndex : valor minimo de altura a considerar
415 maxIndex : valor maximo de altura a considerar
416
417 Affected:
418 self.dataOutObj.data_spc
419 self.dataOutObj.data_cspc
420 self.dataOutObj.data_dc
421 self.dataOutObj.heightList
422 self.dataOutObj.nHeights
423 self.dataOutObj.m_ProcessingHeader.numHeights
424 self.dataOutObj.m_ProcessingHeader.blockSize
425 self.dataOutObj.m_ProcessingHeader.firstHeight
426 self.dataOutObj.m_RadarControllerHeader.numHeights
427
428 Return:
429 None
430 """
431
432 if self.dataOutObj.flagNoData:
433 return 0
434
435 nchannels = self.dataOutObj.nChannels
436 npairs = self.dataOutObj.nPairs
437 profiles = self.dataOutObj.nProfiles
438 dataType = self.dataOutObj.dataType
439 newheis = maxIndex - minIndex + 1
440 blockSize = 0
441
442 #self spectra
443 spc = numpy.zeros( (nchannels,profiles,newheis), dataType[0] )
444 for i in range(nchannels):
445 spc[i,:,:] = self.dataOutObj.data_spc[i,:,minIndex:maxIndex+1]
446
447 #cross spectra
448 cspc = numpy.zeros( (npairs,profiles,newheis), dtype='complex')
449 for i in range(npairs):
450 cspc[i,:,:] = self.dataOutObj.data_cspc[i,:,minIndex:maxIndex+1]
451
452 #DC channel
453 dc = numpy.zeros( (nchannels,newheis), dtype='complex')
454 for i in range(nchannels):
455 dc[i] = self.dataOutObj.data_dc[i,minIndex:maxIndex+1]
456
457 self.dataOutObj.data_spc = spc
458 self.dataOutObj.data_cspc = cspc
459 self.dataOutObj.data_dc = dc
460
461 firstHeight = self.dataOutObj.heightList[minIndex]
462
463 self.dataOutObj.nHeights = newheis
464 self.dataOutObj.m_ProcessingHeader.blockSize = spc.size + cspc.size + dc.size
465 self.dataOutObj.m_ProcessingHeader.numHeights = newheis
466 self.dataOutObj.m_ProcessingHeader.firstHeight = firstHeight
467 self.dataOutObj.m_RadarControllerHeader.numHeights = newheis
468
469 xi = firstHeight
470 step = self.dataOutObj.m_ProcessingHeader.deltaHeight
471 xf = xi + newheis * step
472 self.dataOutObj.heightList = numpy.arange(xi, xf, step)
473
474
162 class IncoherentIntegration:
475 class IncoherentIntegration:
163 def __init__(self, N):
476 def __init__(self, N):
164 self.profCounter = 1
477 self.profCounter = 1
General Comments 0
You need to be logged in to leave comments. Login now