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