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