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