##// END OF EJS Templates
schain
RSS
Error comparing "code == None", it was replaced by "code is None:"
Miguel Valdez -
r674:a8c22d5c048b
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1095 +1,1095
1 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
650 dataOut.flagNoData = True
651
651
652 if dataOut.flagDecodeData:
652 if dataOut.flagDecodeData:
653 print "This data is already decoded, recoding again ..."
653 print "This data is already decoded, recoding again ..."
654
654
655 if not self.isConfig:
655 if not self.isConfig:
656
656
657 if code is None:
657 if code is None:
658 if not dataOut.code:
658 if dataOut.code is None:
659 print "Code is not defined"
659 print "Code is not defined"
660 raise ValueError, "Code could not be read from %s object. Enter a value in Code parameter" %dataOut.type
660 raise ValueError, "Code could not be read from %s object. Enter a value in Code parameter" %dataOut.type
661
661
662 code = dataOut.code
662 code = dataOut.code
663 else:
663 else:
664 code = numpy.array(code).reshape(nCode,nBaud)
664 code = numpy.array(code).reshape(nCode,nBaud)
665
665
666 self.setup(code, osamp, dataOut)
666 self.setup(code, osamp, dataOut)
667
667
668 self.isConfig = True
668 self.isConfig = True
669
669
670 if self.code is None:
670 if self.code is None:
671 print "Fail decoding: Code is not defined."
671 print "Fail decoding: Code is not defined."
672 return
672 return
673
673
674 datadec = None
674 datadec = None
675
675
676 if dataOut.flagDataAsBlock:
676 if dataOut.flagDataAsBlock:
677 """
677 """
678 Decoding when data have been read as block,
678 Decoding when data have been read as block,
679 """
679 """
680 if mode == 0:
680 if mode == 0:
681 datadec = self.__convolutionByBlockInTime(dataOut.data)
681 datadec = self.__convolutionByBlockInTime(dataOut.data)
682 if mode == 1:
682 if mode == 1:
683 datadec = self.__convolutionByBlockInFreq(dataOut.data)
683 datadec = self.__convolutionByBlockInFreq(dataOut.data)
684 else:
684 else:
685 """
685 """
686 Decoding when data have been read profile by profile
686 Decoding when data have been read profile by profile
687 """
687 """
688 if mode == 0:
688 if mode == 0:
689 datadec = self.__convolutionInTime(dataOut.data)
689 datadec = self.__convolutionInTime(dataOut.data)
690
690
691 if mode == 1:
691 if mode == 1:
692 datadec = self.__convolutionInFreq(dataOut.data)
692 datadec = self.__convolutionInFreq(dataOut.data)
693
693
694 if mode == 2:
694 if mode == 2:
695 datadec = self.__convolutionInFreqOpt(dataOut.data)
695 datadec = self.__convolutionInFreqOpt(dataOut.data)
696
696
697 if datadec is None:
697 if datadec is None:
698 raise ValueError, "Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode
698 raise ValueError, "Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode
699
699
700 dataOut.code = self.code
700 dataOut.code = self.code
701 dataOut.nCode = self.nCode
701 dataOut.nCode = self.nCode
702 dataOut.nBaud = self.nBaud
702 dataOut.nBaud = self.nBaud
703
703
704 dataOut.data = datadec
704 dataOut.data = datadec
705
705
706 dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
706 dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
707
707
708 dataOut.flagDecodeData = True #asumo q la data esta decodificada
708 dataOut.flagDecodeData = True #asumo q la data esta decodificada
709
709
710 if self.__profIndex == self.nCode-1:
710 if self.__profIndex == self.nCode-1:
711 self.__profIndex = 0
711 self.__profIndex = 0
712 return 1
712 return 1
713
713
714 self.__profIndex += 1
714 self.__profIndex += 1
715
715
716 dataOut.flagNoData = False
716 dataOut.flagNoData = False
717
717
718 return 1
718 return 1
719 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
719 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
720
720
721
721
722 class ProfileConcat(Operation):
722 class ProfileConcat(Operation):
723
723
724 isConfig = False
724 isConfig = False
725 buffer = None
725 buffer = None
726
726
727 def __init__(self):
727 def __init__(self):
728
728
729 Operation.__init__(self)
729 Operation.__init__(self)
730 self.profileIndex = 0
730 self.profileIndex = 0
731
731
732 def reset(self):
732 def reset(self):
733 self.buffer = numpy.zeros_like(self.buffer)
733 self.buffer = numpy.zeros_like(self.buffer)
734 self.start_index = 0
734 self.start_index = 0
735 self.times = 1
735 self.times = 1
736
736
737 def setup(self, data, m, n=1):
737 def setup(self, data, m, n=1):
738 self.buffer = numpy.zeros((data.shape[0],data.shape[1]*m),dtype=type(data[0,0]))
738 self.buffer = numpy.zeros((data.shape[0],data.shape[1]*m),dtype=type(data[0,0]))
739 self.nHeights = data.nHeights
739 self.nHeights = data.nHeights
740 self.start_index = 0
740 self.start_index = 0
741 self.times = 1
741 self.times = 1
742
742
743 def concat(self, data):
743 def concat(self, data):
744
744
745 self.buffer[:,self.start_index:self.profiles*self.times] = data.copy()
745 self.buffer[:,self.start_index:self.profiles*self.times] = data.copy()
746 self.start_index = self.start_index + self.nHeights
746 self.start_index = self.start_index + self.nHeights
747
747
748 def run(self, dataOut, m):
748 def run(self, dataOut, m):
749
749
750 dataOut.flagNoData = True
750 dataOut.flagNoData = True
751
751
752 if not self.isConfig:
752 if not self.isConfig:
753 self.setup(dataOut.data, m, 1)
753 self.setup(dataOut.data, m, 1)
754 self.isConfig = True
754 self.isConfig = True
755
755
756 if dataOut.flagDataAsBlock:
756 if dataOut.flagDataAsBlock:
757
757
758 raise ValueError, "ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False"
758 raise ValueError, "ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False"
759
759
760 else:
760 else:
761 self.concat(dataOut.data)
761 self.concat(dataOut.data)
762 self.times += 1
762 self.times += 1
763 if self.times > m:
763 if self.times > m:
764 dataOut.data = self.buffer
764 dataOut.data = self.buffer
765 self.reset()
765 self.reset()
766 dataOut.flagNoData = False
766 dataOut.flagNoData = False
767 # se deben actualizar mas propiedades del header y del objeto dataOut, por ejemplo, las alturas
767 # se deben actualizar mas propiedades del header y del objeto dataOut, por ejemplo, las alturas
768 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
768 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
769 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * m
769 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * m
770 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
770 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
771 dataOut.ippSeconds *= m
771 dataOut.ippSeconds *= m
772
772
773 class ProfileSelector(Operation):
773 class ProfileSelector(Operation):
774
774
775 profileIndex = None
775 profileIndex = None
776 # Tamanho total de los perfiles
776 # Tamanho total de los perfiles
777 nProfiles = None
777 nProfiles = None
778
778
779 def __init__(self):
779 def __init__(self):
780
780
781 Operation.__init__(self)
781 Operation.__init__(self)
782 self.profileIndex = 0
782 self.profileIndex = 0
783
783
784 def incIndex(self):
784 def incIndex(self):
785
785
786 self.profileIndex += 1
786 self.profileIndex += 1
787
787
788 if self.profileIndex >= self.nProfiles:
788 if self.profileIndex >= self.nProfiles:
789 self.profileIndex = 0
789 self.profileIndex = 0
790
790
791 def isThisProfileInRange(self, profileIndex, minIndex, maxIndex):
791 def isThisProfileInRange(self, profileIndex, minIndex, maxIndex):
792
792
793 if profileIndex < minIndex:
793 if profileIndex < minIndex:
794 return False
794 return False
795
795
796 if profileIndex > maxIndex:
796 if profileIndex > maxIndex:
797 return False
797 return False
798
798
799 return True
799 return True
800
800
801 def isThisProfileInList(self, profileIndex, profileList):
801 def isThisProfileInList(self, profileIndex, profileList):
802
802
803 if profileIndex not in profileList:
803 if profileIndex not in profileList:
804 return False
804 return False
805
805
806 return True
806 return True
807
807
808 def run(self, dataOut, profileList=None, profileRangeList=None, beam=None, byblock=False, rangeList = None, nProfiles=None):
808 def run(self, dataOut, profileList=None, profileRangeList=None, beam=None, byblock=False, rangeList = None, nProfiles=None):
809
809
810 """
810 """
811 ProfileSelector:
811 ProfileSelector:
812
812
813 Inputs:
813 Inputs:
814 profileList : Index of profiles selected. Example: profileList = (0,1,2,7,8)
814 profileList : Index of profiles selected. Example: profileList = (0,1,2,7,8)
815
815
816 profileRangeList : Minimum and maximum profile indexes. Example: profileRangeList = (4, 30)
816 profileRangeList : Minimum and maximum profile indexes. Example: profileRangeList = (4, 30)
817
817
818 rangeList : List of profile ranges. Example: rangeList = ((4, 30), (32, 64), (128, 256))
818 rangeList : List of profile ranges. Example: rangeList = ((4, 30), (32, 64), (128, 256))
819
819
820 """
820 """
821
821
822 dataOut.flagNoData = True
822 dataOut.flagNoData = True
823
823
824 if dataOut.flagDataAsBlock:
824 if dataOut.flagDataAsBlock:
825 """
825 """
826 data dimension = [nChannels, nProfiles, nHeis]
826 data dimension = [nChannels, nProfiles, nHeis]
827 """
827 """
828 if profileList != None:
828 if profileList != None:
829 dataOut.data = dataOut.data[:,profileList,:]
829 dataOut.data = dataOut.data[:,profileList,:]
830 dataOut.nProfiles = len(profileList)
830 dataOut.nProfiles = len(profileList)
831 dataOut.profileIndex = dataOut.nProfiles - 1
831 dataOut.profileIndex = dataOut.nProfiles - 1
832
832
833 if profileRangeList != None:
833 if profileRangeList != None:
834 minIndex = profileRangeList[0]
834 minIndex = profileRangeList[0]
835 maxIndex = profileRangeList[1]
835 maxIndex = profileRangeList[1]
836
836
837 dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
837 dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
838 dataOut.nProfiles = maxIndex - minIndex + 1
838 dataOut.nProfiles = maxIndex - minIndex + 1
839 dataOut.profileIndex = dataOut.nProfiles - 1
839 dataOut.profileIndex = dataOut.nProfiles - 1
840
840
841 if rangeList != None:
841 if rangeList != None:
842 raise ValueError, "Profile Selector: Invalid argument rangeList. Not implemented for getByBlock yet"
842 raise ValueError, "Profile Selector: Invalid argument rangeList. Not implemented for getByBlock yet"
843
843
844 dataOut.flagNoData = False
844 dataOut.flagNoData = False
845
845
846 return True
846 return True
847
847
848 """
848 """
849 data dimension = [nChannels, nHeis]
849 data dimension = [nChannels, nHeis]
850 """
850 """
851
851
852 if nProfiles:
852 if nProfiles:
853 self.nProfiles = nProfiles
853 self.nProfiles = nProfiles
854 else:
854 else:
855 self.nProfiles = dataOut.nProfiles
855 self.nProfiles = dataOut.nProfiles
856
856
857 if profileList != None:
857 if profileList != None:
858
858
859 dataOut.nProfiles = len(profileList)
859 dataOut.nProfiles = len(profileList)
860
860
861 if self.isThisProfileInList(dataOut.profileIndex, profileList):
861 if self.isThisProfileInList(dataOut.profileIndex, profileList):
862 dataOut.flagNoData = False
862 dataOut.flagNoData = False
863 dataOut.profileIndex = self.profileIndex
863 dataOut.profileIndex = self.profileIndex
864
864
865 self.incIndex()
865 self.incIndex()
866 return True
866 return True
867
867
868 if profileRangeList != None:
868 if profileRangeList != None:
869
869
870 minIndex = profileRangeList[0]
870 minIndex = profileRangeList[0]
871 maxIndex = profileRangeList[1]
871 maxIndex = profileRangeList[1]
872
872
873 dataOut.nProfiles = maxIndex - minIndex + 1
873 dataOut.nProfiles = maxIndex - minIndex + 1
874
874
875 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
875 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
876 dataOut.flagNoData = False
876 dataOut.flagNoData = False
877 dataOut.profileIndex = self.profileIndex
877 dataOut.profileIndex = self.profileIndex
878
878
879 self.incIndex()
879 self.incIndex()
880 return True
880 return True
881
881
882 if rangeList != None:
882 if rangeList != None:
883
883
884 nProfiles = 0
884 nProfiles = 0
885
885
886 for thisRange in rangeList:
886 for thisRange in rangeList:
887 minIndex = thisRange[0]
887 minIndex = thisRange[0]
888 maxIndex = thisRange[1]
888 maxIndex = thisRange[1]
889
889
890 nProfiles += maxIndex - minIndex + 1
890 nProfiles += maxIndex - minIndex + 1
891
891
892 dataOut.nProfiles = nProfiles
892 dataOut.nProfiles = nProfiles
893
893
894 for thisRange in rangeList:
894 for thisRange in rangeList:
895
895
896 minIndex = thisRange[0]
896 minIndex = thisRange[0]
897 maxIndex = thisRange[1]
897 maxIndex = thisRange[1]
898
898
899 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
899 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
900
900
901 # print "profileIndex = ", dataOut.profileIndex
901 # print "profileIndex = ", dataOut.profileIndex
902
902
903 dataOut.flagNoData = False
903 dataOut.flagNoData = False
904 dataOut.profileIndex = self.profileIndex
904 dataOut.profileIndex = self.profileIndex
905
905
906 self.incIndex()
906 self.incIndex()
907 break
907 break
908 return True
908 return True
909
909
910
910
911 if beam != None: #beam is only for AMISR data
911 if beam != None: #beam is only for AMISR data
912 if self.isThisProfileInList(dataOut.profileIndex, dataOut.beamRangeDict[beam]):
912 if self.isThisProfileInList(dataOut.profileIndex, dataOut.beamRangeDict[beam]):
913 dataOut.flagNoData = False
913 dataOut.flagNoData = False
914 dataOut.profileIndex = self.profileIndex
914 dataOut.profileIndex = self.profileIndex
915
915
916 self.incIndex()
916 self.incIndex()
917
917
918 return True
918 return True
919
919
920 raise ValueError, "ProfileSelector needs profileList, profileRangeList or rangeList parameter"
920 raise ValueError, "ProfileSelector needs profileList, profileRangeList or rangeList parameter"
921
921
922 return False
922 return False
923
923
924
924
925
925
926 class Reshaper(Operation):
926 class Reshaper(Operation):
927
927
928 def __init__(self):
928 def __init__(self):
929
929
930 Operation.__init__(self)
930 Operation.__init__(self)
931 self.updateNewHeights = True
931 self.updateNewHeights = True
932
932
933 def run(self, dataOut, shape):
933 def run(self, dataOut, shape):
934
934
935 if not dataOut.flagDataAsBlock:
935 if not dataOut.flagDataAsBlock:
936 raise ValueError, "Reshaper can only be used when voltage have been read as Block, getBlock = True"
936 raise ValueError, "Reshaper can only be used when voltage have been read as Block, getBlock = True"
937
937
938 if len(shape) != 3:
938 if len(shape) != 3:
939 raise ValueError, "shape len should be equal to 3, (nChannels, nProfiles, nHeis)"
939 raise ValueError, "shape len should be equal to 3, (nChannels, nProfiles, nHeis)"
940
940
941 shape_tuple = tuple(shape)
941 shape_tuple = tuple(shape)
942 dataOut.data = numpy.reshape(dataOut.data, shape_tuple)
942 dataOut.data = numpy.reshape(dataOut.data, shape_tuple)
943 dataOut.flagNoData = False
943 dataOut.flagNoData = False
944
944
945 if self.updateNewHeights:
945 if self.updateNewHeights:
946
946
947 old_nheights = dataOut.nHeights
947 old_nheights = dataOut.nHeights
948 new_nheights = dataOut.data.shape[2]
948 new_nheights = dataOut.data.shape[2]
949 factor = 1.0*new_nheights / old_nheights
949 factor = 1.0*new_nheights / old_nheights
950
950
951 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
951 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
952
952
953 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * factor
953 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * factor
954
954
955 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
955 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
956
956
957 dataOut.nProfiles = dataOut.data.shape[1]
957 dataOut.nProfiles = dataOut.data.shape[1]
958
958
959 dataOut.ippSeconds *= factor
959 dataOut.ippSeconds *= factor
960 #
960 #
961 # import collections
961 # import collections
962 # from scipy.stats import mode
962 # from scipy.stats import mode
963 #
963 #
964 # class Synchronize(Operation):
964 # class Synchronize(Operation):
965 #
965 #
966 # isConfig = False
966 # isConfig = False
967 # __profIndex = 0
967 # __profIndex = 0
968 #
968 #
969 # def __init__(self):
969 # def __init__(self):
970 #
970 #
971 # Operation.__init__(self)
971 # Operation.__init__(self)
972 # # self.isConfig = False
972 # # self.isConfig = False
973 # self.__powBuffer = None
973 # self.__powBuffer = None
974 # self.__startIndex = 0
974 # self.__startIndex = 0
975 # self.__pulseFound = False
975 # self.__pulseFound = False
976 #
976 #
977 # def __findTxPulse(self, dataOut, channel=0, pulse_with = None):
977 # def __findTxPulse(self, dataOut, channel=0, pulse_with = None):
978 #
978 #
979 # #Read data
979 # #Read data
980 #
980 #
981 # powerdB = dataOut.getPower(channel = channel)
981 # powerdB = dataOut.getPower(channel = channel)
982 # noisedB = dataOut.getNoise(channel = channel)[0]
982 # noisedB = dataOut.getNoise(channel = channel)[0]
983 #
983 #
984 # self.__powBuffer.extend(powerdB.flatten())
984 # self.__powBuffer.extend(powerdB.flatten())
985 #
985 #
986 # dataArray = numpy.array(self.__powBuffer)
986 # dataArray = numpy.array(self.__powBuffer)
987 #
987 #
988 # filteredPower = numpy.correlate(dataArray, dataArray[0:self.__nSamples], "same")
988 # filteredPower = numpy.correlate(dataArray, dataArray[0:self.__nSamples], "same")
989 #
989 #
990 # maxValue = numpy.nanmax(filteredPower)
990 # maxValue = numpy.nanmax(filteredPower)
991 #
991 #
992 # if maxValue < noisedB + 10:
992 # if maxValue < noisedB + 10:
993 # #No se encuentra ningun pulso de transmision
993 # #No se encuentra ningun pulso de transmision
994 # return None
994 # return None
995 #
995 #
996 # maxValuesIndex = numpy.where(filteredPower > maxValue - 0.1*abs(maxValue))[0]
996 # maxValuesIndex = numpy.where(filteredPower > maxValue - 0.1*abs(maxValue))[0]
997 #
997 #
998 # if len(maxValuesIndex) < 2:
998 # if len(maxValuesIndex) < 2:
999 # #Solo se encontro un solo pulso de transmision de un baudio, esperando por el siguiente TX
999 # #Solo se encontro un solo pulso de transmision de un baudio, esperando por el siguiente TX
1000 # return None
1000 # return None
1001 #
1001 #
1002 # phasedMaxValuesIndex = maxValuesIndex - self.__nSamples
1002 # phasedMaxValuesIndex = maxValuesIndex - self.__nSamples
1003 #
1003 #
1004 # #Seleccionar solo valores con un espaciamiento de nSamples
1004 # #Seleccionar solo valores con un espaciamiento de nSamples
1005 # pulseIndex = numpy.intersect1d(maxValuesIndex, phasedMaxValuesIndex)
1005 # pulseIndex = numpy.intersect1d(maxValuesIndex, phasedMaxValuesIndex)
1006 #
1006 #
1007 # if len(pulseIndex) < 2:
1007 # if len(pulseIndex) < 2:
1008 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1008 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1009 # return None
1009 # return None
1010 #
1010 #
1011 # spacing = pulseIndex[1:] - pulseIndex[:-1]
1011 # spacing = pulseIndex[1:] - pulseIndex[:-1]
1012 #
1012 #
1013 # #remover senales que se distancien menos de 10 unidades o muestras
1013 # #remover senales que se distancien menos de 10 unidades o muestras
1014 # #(No deberian existir IPP menor a 10 unidades)
1014 # #(No deberian existir IPP menor a 10 unidades)
1015 #
1015 #
1016 # realIndex = numpy.where(spacing > 10 )[0]
1016 # realIndex = numpy.where(spacing > 10 )[0]
1017 #
1017 #
1018 # if len(realIndex) < 2:
1018 # if len(realIndex) < 2:
1019 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1019 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1020 # return None
1020 # return None
1021 #
1021 #
1022 # #Eliminar pulsos anchos (deja solo la diferencia entre IPPs)
1022 # #Eliminar pulsos anchos (deja solo la diferencia entre IPPs)
1023 # realPulseIndex = pulseIndex[realIndex]
1023 # realPulseIndex = pulseIndex[realIndex]
1024 #
1024 #
1025 # period = mode(realPulseIndex[1:] - realPulseIndex[:-1])[0][0]
1025 # period = mode(realPulseIndex[1:] - realPulseIndex[:-1])[0][0]
1026 #
1026 #
1027 # print "IPP = %d samples" %period
1027 # print "IPP = %d samples" %period
1028 #
1028 #
1029 # self.__newNSamples = dataOut.nHeights #int(period)
1029 # self.__newNSamples = dataOut.nHeights #int(period)
1030 # self.__startIndex = int(realPulseIndex[0])
1030 # self.__startIndex = int(realPulseIndex[0])
1031 #
1031 #
1032 # return 1
1032 # return 1
1033 #
1033 #
1034 #
1034 #
1035 # def setup(self, nSamples, nChannels, buffer_size = 4):
1035 # def setup(self, nSamples, nChannels, buffer_size = 4):
1036 #
1036 #
1037 # self.__powBuffer = collections.deque(numpy.zeros( buffer_size*nSamples,dtype=numpy.float),
1037 # self.__powBuffer = collections.deque(numpy.zeros( buffer_size*nSamples,dtype=numpy.float),
1038 # maxlen = buffer_size*nSamples)
1038 # maxlen = buffer_size*nSamples)
1039 #
1039 #
1040 # bufferList = []
1040 # bufferList = []
1041 #
1041 #
1042 # for i in range(nChannels):
1042 # for i in range(nChannels):
1043 # bufferByChannel = collections.deque(numpy.zeros( buffer_size*nSamples, dtype=numpy.complex) + numpy.NAN,
1043 # bufferByChannel = collections.deque(numpy.zeros( buffer_size*nSamples, dtype=numpy.complex) + numpy.NAN,
1044 # maxlen = buffer_size*nSamples)
1044 # maxlen = buffer_size*nSamples)
1045 #
1045 #
1046 # bufferList.append(bufferByChannel)
1046 # bufferList.append(bufferByChannel)
1047 #
1047 #
1048 # self.__nSamples = nSamples
1048 # self.__nSamples = nSamples
1049 # self.__nChannels = nChannels
1049 # self.__nChannels = nChannels
1050 # self.__bufferList = bufferList
1050 # self.__bufferList = bufferList
1051 #
1051 #
1052 # def run(self, dataOut, channel = 0):
1052 # def run(self, dataOut, channel = 0):
1053 #
1053 #
1054 # if not self.isConfig:
1054 # if not self.isConfig:
1055 # nSamples = dataOut.nHeights
1055 # nSamples = dataOut.nHeights
1056 # nChannels = dataOut.nChannels
1056 # nChannels = dataOut.nChannels
1057 # self.setup(nSamples, nChannels)
1057 # self.setup(nSamples, nChannels)
1058 # self.isConfig = True
1058 # self.isConfig = True
1059 #
1059 #
1060 # #Append new data to internal buffer
1060 # #Append new data to internal buffer
1061 # for thisChannel in range(self.__nChannels):
1061 # for thisChannel in range(self.__nChannels):
1062 # bufferByChannel = self.__bufferList[thisChannel]
1062 # bufferByChannel = self.__bufferList[thisChannel]
1063 # bufferByChannel.extend(dataOut.data[thisChannel])
1063 # bufferByChannel.extend(dataOut.data[thisChannel])
1064 #
1064 #
1065 # if self.__pulseFound:
1065 # if self.__pulseFound:
1066 # self.__startIndex -= self.__nSamples
1066 # self.__startIndex -= self.__nSamples
1067 #
1067 #
1068 # #Finding Tx Pulse
1068 # #Finding Tx Pulse
1069 # if not self.__pulseFound:
1069 # if not self.__pulseFound:
1070 # indexFound = self.__findTxPulse(dataOut, channel)
1070 # indexFound = self.__findTxPulse(dataOut, channel)
1071 #
1071 #
1072 # if indexFound == None:
1072 # if indexFound == None:
1073 # dataOut.flagNoData = True
1073 # dataOut.flagNoData = True
1074 # return
1074 # return
1075 #
1075 #
1076 # self.__arrayBuffer = numpy.zeros((self.__nChannels, self.__newNSamples), dtype = numpy.complex)
1076 # self.__arrayBuffer = numpy.zeros((self.__nChannels, self.__newNSamples), dtype = numpy.complex)
1077 # self.__pulseFound = True
1077 # self.__pulseFound = True
1078 # self.__startIndex = indexFound
1078 # self.__startIndex = indexFound
1079 #
1079 #
1080 # #If pulse was found ...
1080 # #If pulse was found ...
1081 # for thisChannel in range(self.__nChannels):
1081 # for thisChannel in range(self.__nChannels):
1082 # bufferByChannel = self.__bufferList[thisChannel]
1082 # bufferByChannel = self.__bufferList[thisChannel]
1083 # #print self.__startIndex
1083 # #print self.__startIndex
1084 # x = numpy.array(bufferByChannel)
1084 # x = numpy.array(bufferByChannel)
1085 # self.__arrayBuffer[thisChannel] = x[self.__startIndex:self.__startIndex+self.__newNSamples]
1085 # self.__arrayBuffer[thisChannel] = x[self.__startIndex:self.__startIndex+self.__newNSamples]
1086 #
1086 #
1087 # deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1087 # deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1088 # dataOut.heightList = numpy.arange(self.__newNSamples)*deltaHeight
1088 # dataOut.heightList = numpy.arange(self.__newNSamples)*deltaHeight
1089 # # dataOut.ippSeconds = (self.__newNSamples / deltaHeight)/1e6
1089 # # dataOut.ippSeconds = (self.__newNSamples / deltaHeight)/1e6
1090 #
1090 #
1091 # dataOut.data = self.__arrayBuffer
1091 # dataOut.data = self.__arrayBuffer
1092 #
1092 #
1093 # self.__startIndex += self.__newNSamples
1093 # self.__startIndex += self.__newNSamples
1094 #
1094 #
1095 # return No newline at end of file
1095 # return
General Comments 0
You need to be logged in to leave comments. Login now