##// END OF EJS Templates
schain
RSS
Test codificacion
Miguel Valdez -
r312:9b49805ac04b
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1320 +1,1328
1 '''
1 '''
2
2
3 $Author: dsuarez $
3 $Author: dsuarez $
4 $Id: Processor.py 1 2012-11-12 18:56:07Z dsuarez $
4 $Id: Processor.py 1 2012-11-12 18:56:07Z dsuarez $
5 '''
5 '''
6 import os
6 import os
7 import numpy
7 import numpy
8 import datetime
8 import datetime
9 import time
9 import time
10
10
11 from jrodata import *
11 from jrodata import *
12 from jrodataIO import *
12 from jrodataIO import *
13 from jroplot import *
13 from jroplot import *
14
14
15 try:
15 try:
16 import cfunctions
16 import cfunctions
17 except:
17 except:
18 pass
18 pass
19
19
20 class ProcessingUnit:
20 class ProcessingUnit:
21
21
22 """
22 """
23 Esta es la clase base para el procesamiento de datos.
23 Esta es la clase base para el procesamiento de datos.
24
24
25 Contiene el metodo "call" para llamar operaciones. Las operaciones pueden ser:
25 Contiene el metodo "call" para llamar operaciones. Las operaciones pueden ser:
26 - Metodos internos (callMethod)
26 - Metodos internos (callMethod)
27 - Objetos del tipo Operation (callObject). Antes de ser llamados, estos objetos
27 - Objetos del tipo Operation (callObject). Antes de ser llamados, estos objetos
28 tienen que ser agreagados con el metodo "add".
28 tienen que ser agreagados con el metodo "add".
29
29
30 """
30 """
31 # objeto de datos de entrada (Voltage, Spectra o Correlation)
31 # objeto de datos de entrada (Voltage, Spectra o Correlation)
32 dataIn = None
32 dataIn = None
33
33
34 # objeto de datos de entrada (Voltage, Spectra o Correlation)
34 # objeto de datos de entrada (Voltage, Spectra o Correlation)
35 dataOut = None
35 dataOut = None
36
36
37
37
38 objectDict = None
38 objectDict = None
39
39
40 def __init__(self):
40 def __init__(self):
41
41
42 self.objectDict = {}
42 self.objectDict = {}
43
43
44 def init(self):
44 def init(self):
45
45
46 raise ValueError, "Not implemented"
46 raise ValueError, "Not implemented"
47
47
48 def addOperation(self, object, objId):
48 def addOperation(self, object, objId):
49
49
50 """
50 """
51 Agrega el objeto "object" a la lista de objetos "self.objectList" y retorna el
51 Agrega el objeto "object" a la lista de objetos "self.objectList" y retorna el
52 identificador asociado a este objeto.
52 identificador asociado a este objeto.
53
53
54 Input:
54 Input:
55
55
56 object : objeto de la clase "Operation"
56 object : objeto de la clase "Operation"
57
57
58 Return:
58 Return:
59
59
60 objId : identificador del objeto, necesario para ejecutar la operacion
60 objId : identificador del objeto, necesario para ejecutar la operacion
61 """
61 """
62
62
63 self.objectDict[objId] = object
63 self.objectDict[objId] = object
64
64
65 return objId
65 return objId
66
66
67 def operation(self, **kwargs):
67 def operation(self, **kwargs):
68
68
69 """
69 """
70 Operacion directa sobre la data (dataOut.data). Es necesario actualizar los valores de los
70 Operacion directa sobre la data (dataOut.data). Es necesario actualizar los valores de los
71 atributos del objeto dataOut
71 atributos del objeto dataOut
72
72
73 Input:
73 Input:
74
74
75 **kwargs : Diccionario de argumentos de la funcion a ejecutar
75 **kwargs : Diccionario de argumentos de la funcion a ejecutar
76 """
76 """
77
77
78 raise ValueError, "ImplementedError"
78 raise ValueError, "ImplementedError"
79
79
80 def callMethod(self, name, **kwargs):
80 def callMethod(self, name, **kwargs):
81
81
82 """
82 """
83 Ejecuta el metodo con el nombre "name" y con argumentos **kwargs de la propia clase.
83 Ejecuta el metodo con el nombre "name" y con argumentos **kwargs de la propia clase.
84
84
85 Input:
85 Input:
86 name : nombre del metodo a ejecutar
86 name : nombre del metodo a ejecutar
87
87
88 **kwargs : diccionario con los nombres y valores de la funcion a ejecutar.
88 **kwargs : diccionario con los nombres y valores de la funcion a ejecutar.
89
89
90 """
90 """
91 if name != 'run':
91 if name != 'run':
92
92
93 if name == 'init' and self.dataIn.isEmpty():
93 if name == 'init' and self.dataIn.isEmpty():
94 self.dataOut.flagNoData = True
94 self.dataOut.flagNoData = True
95 return False
95 return False
96
96
97 if name != 'init' and self.dataOut.isEmpty():
97 if name != 'init' and self.dataOut.isEmpty():
98 return False
98 return False
99
99
100 methodToCall = getattr(self, name)
100 methodToCall = getattr(self, name)
101
101
102 methodToCall(**kwargs)
102 methodToCall(**kwargs)
103
103
104 if name != 'run':
104 if name != 'run':
105 return True
105 return True
106
106
107 if self.dataOut.isEmpty():
107 if self.dataOut.isEmpty():
108 return False
108 return False
109
109
110 return True
110 return True
111
111
112 def callObject(self, objId, **kwargs):
112 def callObject(self, objId, **kwargs):
113
113
114 """
114 """
115 Ejecuta la operacion asociada al identificador del objeto "objId"
115 Ejecuta la operacion asociada al identificador del objeto "objId"
116
116
117 Input:
117 Input:
118
118
119 objId : identificador del objeto a ejecutar
119 objId : identificador del objeto a ejecutar
120
120
121 **kwargs : diccionario con los nombres y valores de la funcion a ejecutar.
121 **kwargs : diccionario con los nombres y valores de la funcion a ejecutar.
122
122
123 Return:
123 Return:
124
124
125 None
125 None
126 """
126 """
127
127
128 if self.dataOut.isEmpty():
128 if self.dataOut.isEmpty():
129 return False
129 return False
130
130
131 object = self.objectDict[objId]
131 object = self.objectDict[objId]
132
132
133 object.run(self.dataOut, **kwargs)
133 object.run(self.dataOut, **kwargs)
134
134
135 return True
135 return True
136
136
137 def call(self, operationConf, **kwargs):
137 def call(self, operationConf, **kwargs):
138
138
139 """
139 """
140 Return True si ejecuta la operacion "operationConf.name" con los
140 Return True si ejecuta la operacion "operationConf.name" con los
141 argumentos "**kwargs". False si la operacion no se ha ejecutado.
141 argumentos "**kwargs". False si la operacion no se ha ejecutado.
142 La operacion puede ser de dos tipos:
142 La operacion puede ser de dos tipos:
143
143
144 1. Un metodo propio de esta clase:
144 1. Un metodo propio de esta clase:
145
145
146 operation.type = "self"
146 operation.type = "self"
147
147
148 2. El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
148 2. El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
149 operation.type = "other".
149 operation.type = "other".
150
150
151 Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
151 Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
152 "addOperation" e identificado con el operation.id
152 "addOperation" e identificado con el operation.id
153
153
154
154
155 con el id de la operacion.
155 con el id de la operacion.
156
156
157 Input:
157 Input:
158
158
159 Operation : Objeto del tipo operacion con los atributos: name, type y id.
159 Operation : Objeto del tipo operacion con los atributos: name, type y id.
160
160
161 """
161 """
162
162
163 if operationConf.type == 'self':
163 if operationConf.type == 'self':
164 sts = self.callMethod(operationConf.name, **kwargs)
164 sts = self.callMethod(operationConf.name, **kwargs)
165
165
166 if operationConf.type == 'other':
166 if operationConf.type == 'other':
167 sts = self.callObject(operationConf.id, **kwargs)
167 sts = self.callObject(operationConf.id, **kwargs)
168
168
169 return sts
169 return sts
170
170
171 def setInput(self, dataIn):
171 def setInput(self, dataIn):
172
172
173 self.dataIn = dataIn
173 self.dataIn = dataIn
174
174
175 def getOutput(self):
175 def getOutput(self):
176
176
177 return self.dataOut
177 return self.dataOut
178
178
179 class Operation():
179 class Operation():
180
180
181 """
181 """
182 Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
182 Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
183 y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
183 y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
184 acumulacion dentro de esta clase
184 acumulacion dentro de esta clase
185
185
186 Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
186 Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
187
187
188 """
188 """
189
189
190 __buffer = None
190 __buffer = None
191 __isConfig = False
191 __isConfig = False
192
192
193 def __init__(self):
193 def __init__(self):
194
194
195 pass
195 pass
196
196
197 def run(self, dataIn, **kwargs):
197 def run(self, dataIn, **kwargs):
198
198
199 """
199 """
200 Realiza las operaciones necesarias sobre la dataIn.data y actualiza los atributos del objeto dataIn.
200 Realiza las operaciones necesarias sobre la dataIn.data y actualiza los atributos del objeto dataIn.
201
201
202 Input:
202 Input:
203
203
204 dataIn : objeto del tipo JROData
204 dataIn : objeto del tipo JROData
205
205
206 Return:
206 Return:
207
207
208 None
208 None
209
209
210 Affected:
210 Affected:
211 __buffer : buffer de recepcion de datos.
211 __buffer : buffer de recepcion de datos.
212
212
213 """
213 """
214
214
215 raise ValueError, "ImplementedError"
215 raise ValueError, "ImplementedError"
216
216
217 class VoltageProc(ProcessingUnit):
217 class VoltageProc(ProcessingUnit):
218
218
219
219
220 def __init__(self):
220 def __init__(self):
221
221
222 self.objectDict = {}
222 self.objectDict = {}
223 self.dataOut = Voltage()
223 self.dataOut = Voltage()
224 self.flip = 1
224 self.flip = 1
225
225
226 def init(self):
226 def init(self):
227
227
228 self.dataOut.copy(self.dataIn)
228 self.dataOut.copy(self.dataIn)
229 # No necesita copiar en cada init() los atributos de dataIn
229 # No necesita copiar en cada init() los atributos de dataIn
230 # la copia deberia hacerse por cada nuevo bloque de datos
230 # la copia deberia hacerse por cada nuevo bloque de datos
231
231
232 def selectChannels(self, channelList):
232 def selectChannels(self, channelList):
233
233
234 channelIndexList = []
234 channelIndexList = []
235
235
236 for channel in channelList:
236 for channel in channelList:
237 index = self.dataOut.channelList.index(channel)
237 index = self.dataOut.channelList.index(channel)
238 channelIndexList.append(index)
238 channelIndexList.append(index)
239
239
240 self.selectChannelsByIndex(channelIndexList)
240 self.selectChannelsByIndex(channelIndexList)
241
241
242 def selectChannelsByIndex(self, channelIndexList):
242 def selectChannelsByIndex(self, channelIndexList):
243 """
243 """
244 Selecciona un bloque de datos en base a canales segun el channelIndexList
244 Selecciona un bloque de datos en base a canales segun el channelIndexList
245
245
246 Input:
246 Input:
247 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
247 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
248
248
249 Affected:
249 Affected:
250 self.dataOut.data
250 self.dataOut.data
251 self.dataOut.channelIndexList
251 self.dataOut.channelIndexList
252 self.dataOut.nChannels
252 self.dataOut.nChannels
253 self.dataOut.m_ProcessingHeader.totalSpectra
253 self.dataOut.m_ProcessingHeader.totalSpectra
254 self.dataOut.systemHeaderObj.numChannels
254 self.dataOut.systemHeaderObj.numChannels
255 self.dataOut.m_ProcessingHeader.blockSize
255 self.dataOut.m_ProcessingHeader.blockSize
256
256
257 Return:
257 Return:
258 None
258 None
259 """
259 """
260
260
261 for channelIndex in channelIndexList:
261 for channelIndex in channelIndexList:
262 if channelIndex not in self.dataOut.channelIndexList:
262 if channelIndex not in self.dataOut.channelIndexList:
263 print channelIndexList
263 print channelIndexList
264 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
264 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
265
265
266 nChannels = len(channelIndexList)
266 nChannels = len(channelIndexList)
267
267
268 data = self.dataOut.data[channelIndexList,:]
268 data = self.dataOut.data[channelIndexList,:]
269
269
270 self.dataOut.data = data
270 self.dataOut.data = data
271 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
271 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
272 # self.dataOut.nChannels = nChannels
272 # self.dataOut.nChannels = nChannels
273
273
274 return 1
274 return 1
275
275
276 def selectHeights(self, minHei, maxHei):
276 def selectHeights(self, minHei, maxHei):
277 """
277 """
278 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
278 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
279 minHei <= height <= maxHei
279 minHei <= height <= maxHei
280
280
281 Input:
281 Input:
282 minHei : valor minimo de altura a considerar
282 minHei : valor minimo de altura a considerar
283 maxHei : valor maximo de altura a considerar
283 maxHei : valor maximo de altura a considerar
284
284
285 Affected:
285 Affected:
286 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
286 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
287
287
288 Return:
288 Return:
289 1 si el metodo se ejecuto con exito caso contrario devuelve 0
289 1 si el metodo se ejecuto con exito caso contrario devuelve 0
290 """
290 """
291 if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
291 if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
292 raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
292 raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
293
293
294 if (maxHei > self.dataOut.heightList[-1]):
294 if (maxHei > self.dataOut.heightList[-1]):
295 maxHei = self.dataOut.heightList[-1]
295 maxHei = self.dataOut.heightList[-1]
296 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
296 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
297
297
298 minIndex = 0
298 minIndex = 0
299 maxIndex = 0
299 maxIndex = 0
300 heights = self.dataOut.heightList
300 heights = self.dataOut.heightList
301
301
302 inda = numpy.where(heights >= minHei)
302 inda = numpy.where(heights >= minHei)
303 indb = numpy.where(heights <= maxHei)
303 indb = numpy.where(heights <= maxHei)
304
304
305 try:
305 try:
306 minIndex = inda[0][0]
306 minIndex = inda[0][0]
307 except:
307 except:
308 minIndex = 0
308 minIndex = 0
309
309
310 try:
310 try:
311 maxIndex = indb[0][-1]
311 maxIndex = indb[0][-1]
312 except:
312 except:
313 maxIndex = len(heights)
313 maxIndex = len(heights)
314
314
315 self.selectHeightsByIndex(minIndex, maxIndex)
315 self.selectHeightsByIndex(minIndex, maxIndex)
316
316
317 return 1
317 return 1
318
318
319
319
320 def selectHeightsByIndex(self, minIndex, maxIndex):
320 def selectHeightsByIndex(self, minIndex, maxIndex):
321 """
321 """
322 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
322 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
323 minIndex <= index <= maxIndex
323 minIndex <= index <= maxIndex
324
324
325 Input:
325 Input:
326 minIndex : valor de indice minimo de altura a considerar
326 minIndex : valor de indice minimo de altura a considerar
327 maxIndex : valor de indice maximo de altura a considerar
327 maxIndex : valor de indice maximo de altura a considerar
328
328
329 Affected:
329 Affected:
330 self.dataOut.data
330 self.dataOut.data
331 self.dataOut.heightList
331 self.dataOut.heightList
332
332
333 Return:
333 Return:
334 1 si el metodo se ejecuto con exito caso contrario devuelve 0
334 1 si el metodo se ejecuto con exito caso contrario devuelve 0
335 """
335 """
336
336
337 if (minIndex < 0) or (minIndex > maxIndex):
337 if (minIndex < 0) or (minIndex > maxIndex):
338 raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
338 raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
339
339
340 if (maxIndex >= self.dataOut.nHeights):
340 if (maxIndex >= self.dataOut.nHeights):
341 maxIndex = self.dataOut.nHeights-1
341 maxIndex = self.dataOut.nHeights-1
342 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
342 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
343
343
344 nHeights = maxIndex - minIndex + 1
344 nHeights = maxIndex - minIndex + 1
345
345
346 #voltage
346 #voltage
347 data = self.dataOut.data[:,minIndex:maxIndex+1]
347 data = self.dataOut.data[:,minIndex:maxIndex+1]
348
348
349 firstHeight = self.dataOut.heightList[minIndex]
349 firstHeight = self.dataOut.heightList[minIndex]
350
350
351 self.dataOut.data = data
351 self.dataOut.data = data
352 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
352 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
353
353
354 return 1
354 return 1
355
355
356
356
357 def filterByHeights(self, window):
357 def filterByHeights(self, window):
358 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
358 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
359
359
360 if window == None:
360 if window == None:
361 window = self.dataOut.radarControllerHeaderObj.txA / deltaHeight
361 window = self.dataOut.radarControllerHeaderObj.txA / deltaHeight
362
362
363 newdelta = deltaHeight * window
363 newdelta = deltaHeight * window
364 r = self.dataOut.data.shape[1] % window
364 r = self.dataOut.data.shape[1] % window
365 buffer = self.dataOut.data[:,0:self.dataOut.data.shape[1]-r]
365 buffer = self.dataOut.data[:,0:self.dataOut.data.shape[1]-r]
366 buffer = buffer.reshape(self.dataOut.data.shape[0],self.dataOut.data.shape[1]/window,window)
366 buffer = buffer.reshape(self.dataOut.data.shape[0],self.dataOut.data.shape[1]/window,window)
367 buffer = numpy.sum(buffer,2)
367 buffer = numpy.sum(buffer,2)
368 self.dataOut.data = buffer
368 self.dataOut.data = buffer
369 self.dataOut.heightList = numpy.arange(self.dataOut.heightList[0],newdelta*self.dataOut.nHeights/window-newdelta,newdelta)
369 self.dataOut.heightList = numpy.arange(self.dataOut.heightList[0],newdelta*self.dataOut.nHeights/window-newdelta,newdelta)
370 self.dataOut.windowOfFilter = window
370 self.dataOut.windowOfFilter = window
371
371
372 def deFlip(self):
372 def deFlip(self):
373 self.dataOut.data *= self.flip
373 self.dataOut.data *= self.flip
374 self.flip *= -1.
374 self.flip *= -1.
375
375
376
376
377 class CohInt(Operation):
377 class CohInt(Operation):
378
378
379 __isConfig = False
379 __isConfig = False
380
380
381 __profIndex = 0
381 __profIndex = 0
382 __withOverapping = False
382 __withOverapping = False
383
383
384 __byTime = False
384 __byTime = False
385 __initime = None
385 __initime = None
386 __lastdatatime = None
386 __lastdatatime = None
387 __integrationtime = None
387 __integrationtime = None
388
388
389 __buffer = None
389 __buffer = None
390
390
391 __dataReady = False
391 __dataReady = False
392
392
393 n = None
393 n = None
394
394
395
395
396 def __init__(self):
396 def __init__(self):
397
397
398 self.__isConfig = False
398 self.__isConfig = False
399
399
400 def setup(self, n=None, timeInterval=None, overlapping=False):
400 def setup(self, n=None, timeInterval=None, overlapping=False):
401 """
401 """
402 Set the parameters of the integration class.
402 Set the parameters of the integration class.
403
403
404 Inputs:
404 Inputs:
405
405
406 n : Number of coherent integrations
406 n : Number of coherent integrations
407 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
407 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
408 overlapping :
408 overlapping :
409
409
410 """
410 """
411
411
412 self.__initime = None
412 self.__initime = None
413 self.__lastdatatime = 0
413 self.__lastdatatime = 0
414 self.__buffer = None
414 self.__buffer = None
415 self.__dataReady = False
415 self.__dataReady = False
416
416
417
417
418 if n == None and timeInterval == None:
418 if n == None and timeInterval == None:
419 raise ValueError, "n or timeInterval should be specified ..."
419 raise ValueError, "n or timeInterval should be specified ..."
420
420
421 if n != None:
421 if n != None:
422 self.n = n
422 self.n = n
423 self.__byTime = False
423 self.__byTime = False
424 else:
424 else:
425 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
425 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
426 self.n = 9999
426 self.n = 9999
427 self.__byTime = True
427 self.__byTime = True
428
428
429 if overlapping:
429 if overlapping:
430 self.__withOverapping = True
430 self.__withOverapping = True
431 self.__buffer = None
431 self.__buffer = None
432 else:
432 else:
433 self.__withOverapping = False
433 self.__withOverapping = False
434 self.__buffer = 0
434 self.__buffer = 0
435
435
436 self.__profIndex = 0
436 self.__profIndex = 0
437
437
438 def putData(self, data):
438 def putData(self, data):
439
439
440 """
440 """
441 Add a profile to the __buffer and increase in one the __profileIndex
441 Add a profile to the __buffer and increase in one the __profileIndex
442
442
443 """
443 """
444
444
445 if not self.__withOverapping:
445 if not self.__withOverapping:
446 self.__buffer += data.copy()
446 self.__buffer += data.copy()
447 self.__profIndex += 1
447 self.__profIndex += 1
448 return
448 return
449
449
450 #Overlapping data
450 #Overlapping data
451 nChannels, nHeis = data.shape
451 nChannels, nHeis = data.shape
452 data = numpy.reshape(data, (1, nChannels, nHeis))
452 data = numpy.reshape(data, (1, nChannels, nHeis))
453
453
454 #If the buffer is empty then it takes the data value
454 #If the buffer is empty then it takes the data value
455 if self.__buffer == None:
455 if self.__buffer == None:
456 self.__buffer = data
456 self.__buffer = data
457 self.__profIndex += 1
457 self.__profIndex += 1
458 return
458 return
459
459
460 #If the buffer length is lower than n then stakcing the data value
460 #If the buffer length is lower than n then stakcing the data value
461 if self.__profIndex < self.n:
461 if self.__profIndex < self.n:
462 self.__buffer = numpy.vstack((self.__buffer, data))
462 self.__buffer = numpy.vstack((self.__buffer, data))
463 self.__profIndex += 1
463 self.__profIndex += 1
464 return
464 return
465
465
466 #If the buffer length is equal to n then replacing the last buffer value with the data value
466 #If the buffer length is equal to n then replacing the last buffer value with the data value
467 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
467 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
468 self.__buffer[self.n-1] = data
468 self.__buffer[self.n-1] = data
469 self.__profIndex = self.n
469 self.__profIndex = self.n
470 return
470 return
471
471
472
472
473 def pushData(self):
473 def pushData(self):
474 """
474 """
475 Return the sum of the last profiles and the profiles used in the sum.
475 Return the sum of the last profiles and the profiles used in the sum.
476
476
477 Affected:
477 Affected:
478
478
479 self.__profileIndex
479 self.__profileIndex
480
480
481 """
481 """
482
482
483 if not self.__withOverapping:
483 if not self.__withOverapping:
484 data = self.__buffer
484 data = self.__buffer
485 n = self.__profIndex
485 n = self.__profIndex
486
486
487 self.__buffer = 0
487 self.__buffer = 0
488 self.__profIndex = 0
488 self.__profIndex = 0
489
489
490 return data, n
490 return data, n
491
491
492 #Integration with Overlapping
492 #Integration with Overlapping
493 data = numpy.sum(self.__buffer, axis=0)
493 data = numpy.sum(self.__buffer, axis=0)
494 n = self.__profIndex
494 n = self.__profIndex
495
495
496 return data, n
496 return data, n
497
497
498 def byProfiles(self, data):
498 def byProfiles(self, data):
499
499
500 self.__dataReady = False
500 self.__dataReady = False
501 avgdata = None
501 avgdata = None
502 n = None
502 n = None
503
503
504 self.putData(data)
504 self.putData(data)
505
505
506 if self.__profIndex == self.n:
506 if self.__profIndex == self.n:
507
507
508 avgdata, n = self.pushData()
508 avgdata, n = self.pushData()
509 self.__dataReady = True
509 self.__dataReady = True
510
510
511 return avgdata
511 return avgdata
512
512
513 def byTime(self, data, datatime):
513 def byTime(self, data, datatime):
514
514
515 self.__dataReady = False
515 self.__dataReady = False
516 avgdata = None
516 avgdata = None
517 n = None
517 n = None
518
518
519 self.putData(data)
519 self.putData(data)
520
520
521 if (datatime - self.__initime) >= self.__integrationtime:
521 if (datatime - self.__initime) >= self.__integrationtime:
522 avgdata, n = self.pushData()
522 avgdata, n = self.pushData()
523 self.n = n
523 self.n = n
524 self.__dataReady = True
524 self.__dataReady = True
525
525
526 return avgdata
526 return avgdata
527
527
528 def integrate(self, data, datatime=None):
528 def integrate(self, data, datatime=None):
529
529
530 if self.__initime == None:
530 if self.__initime == None:
531 self.__initime = datatime
531 self.__initime = datatime
532
532
533 if self.__byTime:
533 if self.__byTime:
534 avgdata = self.byTime(data, datatime)
534 avgdata = self.byTime(data, datatime)
535 else:
535 else:
536 avgdata = self.byProfiles(data)
536 avgdata = self.byProfiles(data)
537
537
538
538
539 self.__lastdatatime = datatime
539 self.__lastdatatime = datatime
540
540
541 if avgdata == None:
541 if avgdata == None:
542 return None, None
542 return None, None
543
543
544 avgdatatime = self.__initime
544 avgdatatime = self.__initime
545
545
546 deltatime = datatime -self.__lastdatatime
546 deltatime = datatime -self.__lastdatatime
547
547
548 if not self.__withOverapping:
548 if not self.__withOverapping:
549 self.__initime = datatime
549 self.__initime = datatime
550 else:
550 else:
551 self.__initime += deltatime
551 self.__initime += deltatime
552
552
553 return avgdata, avgdatatime
553 return avgdata, avgdatatime
554
554
555 def run(self, dataOut, **kwargs):
555 def run(self, dataOut, **kwargs):
556
556
557 if not self.__isConfig:
557 if not self.__isConfig:
558 self.setup(**kwargs)
558 self.setup(**kwargs)
559 self.__isConfig = True
559 self.__isConfig = True
560
560
561 avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
561 avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
562
562
563 # dataOut.timeInterval *= n
563 # dataOut.timeInterval *= n
564 dataOut.flagNoData = True
564 dataOut.flagNoData = True
565
565
566 if self.__dataReady:
566 if self.__dataReady:
567 dataOut.data = avgdata
567 dataOut.data = avgdata
568 dataOut.nCohInt *= self.n
568 dataOut.nCohInt *= self.n
569 dataOut.utctime = avgdatatime
569 dataOut.utctime = avgdatatime
570 dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
570 dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
571 dataOut.flagNoData = False
571 dataOut.flagNoData = False
572
572
573
573
574 class Decoder(Operation):
574 class Decoder(Operation):
575
575
576 __isConfig = False
576 __isConfig = False
577 __profIndex = 0
577 __profIndex = 0
578
578
579 code = None
579 code = None
580
580
581 nCode = None
581 nCode = None
582 nBaud = None
582 nBaud = None
583
583
584 def __init__(self):
584 def __init__(self):
585
585
586 self.__isConfig = False
586 self.__isConfig = False
587
587
588 def setup(self, code, shape):
588 def setup(self, code, shape):
589
589
590 self.__profIndex = 0
590 self.__profIndex = 0
591
591
592 self.code = code
592 self.code = code
593
593
594 self.nCode = len(code)
594 self.nCode = len(code)
595 self.nBaud = len(code[0])
595 self.nBaud = len(code[0])
596
596
597 self.__nChannels, self.__nHeis = shape
597 self.__nChannels, self.__nHeis = shape
598
598
599 __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.float32)
599 __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.float32)
600
600
601 __codeBuffer[:,0:self.nBaud] = self.code
601 __codeBuffer[:,0:self.nBaud] = self.code
602
602
603 self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
603 self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
604
604
605 self.ndatadec = self.__nHeis - self.nBaud + 1
605 self.ndatadec = self.__nHeis - self.nBaud + 1
606
606
607 self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
607 self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
608
608
609 def convolutionInFreq(self, data):
609 def convolutionInFreq(self, data):
610
610
611 ini = time.time()
611 ini = time.time()
612
612
613 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
613 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
614
614
615 print "Freq0 ", time.time() - ini
616
615 fft_data = numpy.fft.fft(data, axis=1)
617 fft_data = numpy.fft.fft(data, axis=1)
616
618
619 print "Freq1 ", time.time() - ini
620
617 conv = fft_data*fft_code
621 conv = fft_data*fft_code
618
622
623 print "Freq2 ", time.time() - ini
624
619 data = numpy.fft.ifft(conv,axis=1)
625 data = numpy.fft.ifft(conv,axis=1)
620
626
627 print "Freq3 ", time.time() - ini
628
621 datadec = data[:,:-self.nBaud+1]
629 datadec = data[:,:-self.nBaud+1]
622
630
623 print "Freq ", time.time() - ini
631 print "Freq4 ", time.time() - ini
624
632
625 return datadec
633 return datadec
626
634
627 def convolutionInFreqOpt(self, data):
635 def convolutionInFreqOpt(self, data):
628
636
629 ini = time.time()
637 ini = time.time()
630
638
631 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
639 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
632
640
633 data = cfunctions.decoder(fft_code, data)
641 data = cfunctions.decoder(fft_code, data)
634
642
635 datadec = data[:,:-self.nBaud+1]
643 datadec = data[:,:-self.nBaud+1]
636
644
637 print "OptFreq ", time.time() - ini
645 print "OptFreq ", time.time() - ini
638
646
639 return datadec
647 return datadec
640
648
641 def convolutionInTime(self, data):
649 def convolutionInTime(self, data):
642
650
643 ini = time.time()
651 ini = time.time()
644
652
645 code = self.code[self.__profIndex].reshape(1,-1)
653 code = self.code[self.__profIndex].reshape(1,-1)
646
654
647 for i in range(self.__nChannels):
655 for i in range(self.__nChannels):
648 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='valid')
656 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='valid')
649
657
650 print "Time ", time.time() - ini
658 print "Time ", time.time() - ini
651
659
652 return self.datadecTime
660 return self.datadecTime
653
661
654 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0):
662 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0):
655 ini = time.time()
663 ini = time.time()
656 if not self.__isConfig:
664 if not self.__isConfig:
657
665
658 if code == None:
666 if code == None:
659 code = dataOut.code
667 code = dataOut.code
660 else:
668 else:
661 code = numpy.array(code).reshape(nCode,nBaud)
669 code = numpy.array(code).reshape(nCode,nBaud)
662 dataOut.code = code
670 dataOut.code = code
663 dataOut.nCode = nCode
671 dataOut.nCode = nCode
664 dataOut.nBaud = nBaud
672 dataOut.nBaud = nBaud
665
673
666 if code == None:
674 if code == None:
667 return 1
675 return 1
668
676
669 self.setup(code, dataOut.data.shape)
677 self.setup(code, dataOut.data.shape)
670 self.__isConfig = True
678 self.__isConfig = True
671
679
672 if mode == 0:
680 if mode == 0:
673 datadec = self.convolutionInFreq(dataOut.data)
681 datadec = self.convolutionInFreq(dataOut.data)
674
682
675 if mode == 1:
683 if mode == 1:
676 datadec = self.convolutionInTime(dataOut.data)
684 datadec = self.convolutionInTime(dataOut.data)
677
685
678 if mode == 2:
686 if mode == 2:
679 datadec = self.convolutionInFreqOpt(dataOut.data)
687 datadec = self.convolutionInFreqOpt(dataOut.data)
680
688
681 dataOut.data = datadec
689 dataOut.data = datadec
682
690
683 dataOut.heightList = dataOut.heightList[0:self.ndatadec]
691 dataOut.heightList = dataOut.heightList[0:self.ndatadec]
684
692
685 dataOut.flagDecodeData = True #asumo q la data no esta decodificada
693 dataOut.flagDecodeData = True #asumo q la data no esta decodificada
686
694
687 print time.time() - ini, "prof = %d, nCode=%d" %(self.__profIndex, self.nCode)
695 print time.time() - ini, "prof = %d, nCode=%d" %(self.__profIndex, self.nCode)
688
696
689 if self.__profIndex == self.nCode-1:
697 if self.__profIndex == self.nCode-1:
690 self.__profIndex = 0
698 self.__profIndex = 0
691 return 1
699 return 1
692
700
693 self.__profIndex += 1
701 self.__profIndex += 1
694
702
695 return 1
703 return 1
696 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
704 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
697
705
698
706
699
707
700 class SpectraProc(ProcessingUnit):
708 class SpectraProc(ProcessingUnit):
701
709
702 def __init__(self):
710 def __init__(self):
703
711
704 self.objectDict = {}
712 self.objectDict = {}
705 self.buffer = None
713 self.buffer = None
706 self.firstdatatime = None
714 self.firstdatatime = None
707 self.profIndex = 0
715 self.profIndex = 0
708 self.dataOut = Spectra()
716 self.dataOut = Spectra()
709
717
710 def __updateObjFromInput(self):
718 def __updateObjFromInput(self):
711
719
712 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
720 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
713 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
721 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
714 self.dataOut.channelList = self.dataIn.channelList
722 self.dataOut.channelList = self.dataIn.channelList
715 self.dataOut.heightList = self.dataIn.heightList
723 self.dataOut.heightList = self.dataIn.heightList
716 self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
724 self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
717 # self.dataOut.nHeights = self.dataIn.nHeights
725 # self.dataOut.nHeights = self.dataIn.nHeights
718 # self.dataOut.nChannels = self.dataIn.nChannels
726 # self.dataOut.nChannels = self.dataIn.nChannels
719 self.dataOut.nBaud = self.dataIn.nBaud
727 self.dataOut.nBaud = self.dataIn.nBaud
720 self.dataOut.nCode = self.dataIn.nCode
728 self.dataOut.nCode = self.dataIn.nCode
721 self.dataOut.code = self.dataIn.code
729 self.dataOut.code = self.dataIn.code
722 self.dataOut.nProfiles = self.dataOut.nFFTPoints
730 self.dataOut.nProfiles = self.dataOut.nFFTPoints
723 # self.dataOut.channelIndexList = self.dataIn.channelIndexList
731 # self.dataOut.channelIndexList = self.dataIn.channelIndexList
724 self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
732 self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
725 self.dataOut.utctime = self.firstdatatime
733 self.dataOut.utctime = self.firstdatatime
726 self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
734 self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
727 self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
735 self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
728 self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
736 self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
729 self.dataOut.nCohInt = self.dataIn.nCohInt
737 self.dataOut.nCohInt = self.dataIn.nCohInt
730 self.dataOut.nIncohInt = 1
738 self.dataOut.nIncohInt = 1
731 self.dataOut.ippSeconds = self.dataIn.ippSeconds
739 self.dataOut.ippSeconds = self.dataIn.ippSeconds
732 self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
740 self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
733
741
734 self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
742 self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
735
743
736 def __getFft(self):
744 def __getFft(self):
737 """
745 """
738 Convierte valores de Voltaje a Spectra
746 Convierte valores de Voltaje a Spectra
739
747
740 Affected:
748 Affected:
741 self.dataOut.data_spc
749 self.dataOut.data_spc
742 self.dataOut.data_cspc
750 self.dataOut.data_cspc
743 self.dataOut.data_dc
751 self.dataOut.data_dc
744 self.dataOut.heightList
752 self.dataOut.heightList
745 self.profIndex
753 self.profIndex
746 self.buffer
754 self.buffer
747 self.dataOut.flagNoData
755 self.dataOut.flagNoData
748 """
756 """
749 fft_volt = numpy.fft.fft(self.buffer,axis=1)
757 fft_volt = numpy.fft.fft(self.buffer,axis=1)
750 fft_volt = fft_volt.astype(numpy.dtype('complex'))
758 fft_volt = fft_volt.astype(numpy.dtype('complex'))
751 dc = fft_volt[:,0,:]
759 dc = fft_volt[:,0,:]
752
760
753 #calculo de self-spectra
761 #calculo de self-spectra
754 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
762 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
755 spc = fft_volt * numpy.conjugate(fft_volt)
763 spc = fft_volt * numpy.conjugate(fft_volt)
756 spc = spc.real
764 spc = spc.real
757
765
758 blocksize = 0
766 blocksize = 0
759 blocksize += dc.size
767 blocksize += dc.size
760 blocksize += spc.size
768 blocksize += spc.size
761
769
762 cspc = None
770 cspc = None
763 pairIndex = 0
771 pairIndex = 0
764 if self.dataOut.pairsList != None:
772 if self.dataOut.pairsList != None:
765 #calculo de cross-spectra
773 #calculo de cross-spectra
766 cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
774 cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
767 for pair in self.dataOut.pairsList:
775 for pair in self.dataOut.pairsList:
768 cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
776 cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
769 pairIndex += 1
777 pairIndex += 1
770 blocksize += cspc.size
778 blocksize += cspc.size
771
779
772 self.dataOut.data_spc = spc
780 self.dataOut.data_spc = spc
773 self.dataOut.data_cspc = cspc
781 self.dataOut.data_cspc = cspc
774 self.dataOut.data_dc = dc
782 self.dataOut.data_dc = dc
775 self.dataOut.blockSize = blocksize
783 self.dataOut.blockSize = blocksize
776
784
777 def init(self, nFFTPoints=None, pairsList=None):
785 def init(self, nFFTPoints=None, pairsList=None):
778
786
779 self.dataOut.flagNoData = True
787 self.dataOut.flagNoData = True
780
788
781 if self.dataIn.type == "Spectra":
789 if self.dataIn.type == "Spectra":
782 self.dataOut.copy(self.dataIn)
790 self.dataOut.copy(self.dataIn)
783 return
791 return
784
792
785 if self.dataIn.type == "Voltage":
793 if self.dataIn.type == "Voltage":
786
794
787 if nFFTPoints == None:
795 if nFFTPoints == None:
788 raise ValueError, "This SpectraProc.init() need nFFTPoints input variable"
796 raise ValueError, "This SpectraProc.init() need nFFTPoints input variable"
789
797
790 if pairsList == None:
798 if pairsList == None:
791 nPairs = 0
799 nPairs = 0
792 else:
800 else:
793 nPairs = len(pairsList)
801 nPairs = len(pairsList)
794
802
795 self.dataOut.nFFTPoints = nFFTPoints
803 self.dataOut.nFFTPoints = nFFTPoints
796 self.dataOut.pairsList = pairsList
804 self.dataOut.pairsList = pairsList
797 self.dataOut.nPairs = nPairs
805 self.dataOut.nPairs = nPairs
798
806
799 if self.buffer == None:
807 if self.buffer == None:
800 self.buffer = numpy.zeros((self.dataIn.nChannels,
808 self.buffer = numpy.zeros((self.dataIn.nChannels,
801 self.dataOut.nFFTPoints,
809 self.dataOut.nFFTPoints,
802 self.dataIn.nHeights),
810 self.dataIn.nHeights),
803 dtype='complex')
811 dtype='complex')
804
812
805
813
806 self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
814 self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
807 self.profIndex += 1
815 self.profIndex += 1
808
816
809 if self.firstdatatime == None:
817 if self.firstdatatime == None:
810 self.firstdatatime = self.dataIn.utctime
818 self.firstdatatime = self.dataIn.utctime
811
819
812 if self.profIndex == self.dataOut.nFFTPoints:
820 if self.profIndex == self.dataOut.nFFTPoints:
813 self.__updateObjFromInput()
821 self.__updateObjFromInput()
814 self.__getFft()
822 self.__getFft()
815
823
816 self.dataOut.flagNoData = False
824 self.dataOut.flagNoData = False
817
825
818 self.buffer = None
826 self.buffer = None
819 self.firstdatatime = None
827 self.firstdatatime = None
820 self.profIndex = 0
828 self.profIndex = 0
821
829
822 return
830 return
823
831
824 raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
832 raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
825
833
826 def selectChannels(self, channelList):
834 def selectChannels(self, channelList):
827
835
828 channelIndexList = []
836 channelIndexList = []
829
837
830 for channel in channelList:
838 for channel in channelList:
831 index = self.dataOut.channelList.index(channel)
839 index = self.dataOut.channelList.index(channel)
832 channelIndexList.append(index)
840 channelIndexList.append(index)
833
841
834 self.selectChannelsByIndex(channelIndexList)
842 self.selectChannelsByIndex(channelIndexList)
835
843
836 def selectChannelsByIndex(self, channelIndexList):
844 def selectChannelsByIndex(self, channelIndexList):
837 """
845 """
838 Selecciona un bloque de datos en base a canales segun el channelIndexList
846 Selecciona un bloque de datos en base a canales segun el channelIndexList
839
847
840 Input:
848 Input:
841 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
849 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
842
850
843 Affected:
851 Affected:
844 self.dataOut.data_spc
852 self.dataOut.data_spc
845 self.dataOut.channelIndexList
853 self.dataOut.channelIndexList
846 self.dataOut.nChannels
854 self.dataOut.nChannels
847
855
848 Return:
856 Return:
849 None
857 None
850 """
858 """
851
859
852 for channelIndex in channelIndexList:
860 for channelIndex in channelIndexList:
853 if channelIndex not in self.dataOut.channelIndexList:
861 if channelIndex not in self.dataOut.channelIndexList:
854 print channelIndexList
862 print channelIndexList
855 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
863 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
856
864
857 nChannels = len(channelIndexList)
865 nChannels = len(channelIndexList)
858
866
859 data_spc = self.dataOut.data_spc[channelIndexList,:]
867 data_spc = self.dataOut.data_spc[channelIndexList,:]
860
868
861 self.dataOut.data_spc = data_spc
869 self.dataOut.data_spc = data_spc
862 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
870 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
863 # self.dataOut.nChannels = nChannels
871 # self.dataOut.nChannels = nChannels
864
872
865 return 1
873 return 1
866
874
867 def selectHeights(self, minHei, maxHei):
875 def selectHeights(self, minHei, maxHei):
868 """
876 """
869 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
877 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
870 minHei <= height <= maxHei
878 minHei <= height <= maxHei
871
879
872 Input:
880 Input:
873 minHei : valor minimo de altura a considerar
881 minHei : valor minimo de altura a considerar
874 maxHei : valor maximo de altura a considerar
882 maxHei : valor maximo de altura a considerar
875
883
876 Affected:
884 Affected:
877 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
885 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
878
886
879 Return:
887 Return:
880 1 si el metodo se ejecuto con exito caso contrario devuelve 0
888 1 si el metodo se ejecuto con exito caso contrario devuelve 0
881 """
889 """
882 if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
890 if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
883 raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
891 raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
884
892
885 if (maxHei > self.dataOut.heightList[-1]):
893 if (maxHei > self.dataOut.heightList[-1]):
886 maxHei = self.dataOut.heightList[-1]
894 maxHei = self.dataOut.heightList[-1]
887 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
895 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
888
896
889 minIndex = 0
897 minIndex = 0
890 maxIndex = 0
898 maxIndex = 0
891 heights = self.dataOut.heightList
899 heights = self.dataOut.heightList
892
900
893 inda = numpy.where(heights >= minHei)
901 inda = numpy.where(heights >= minHei)
894 indb = numpy.where(heights <= maxHei)
902 indb = numpy.where(heights <= maxHei)
895
903
896 try:
904 try:
897 minIndex = inda[0][0]
905 minIndex = inda[0][0]
898 except:
906 except:
899 minIndex = 0
907 minIndex = 0
900
908
901 try:
909 try:
902 maxIndex = indb[0][-1]
910 maxIndex = indb[0][-1]
903 except:
911 except:
904 maxIndex = len(heights)
912 maxIndex = len(heights)
905
913
906 self.selectHeightsByIndex(minIndex, maxIndex)
914 self.selectHeightsByIndex(minIndex, maxIndex)
907
915
908 return 1
916 return 1
909
917
910
918
911 def selectHeightsByIndex(self, minIndex, maxIndex):
919 def selectHeightsByIndex(self, minIndex, maxIndex):
912 """
920 """
913 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
921 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
914 minIndex <= index <= maxIndex
922 minIndex <= index <= maxIndex
915
923
916 Input:
924 Input:
917 minIndex : valor de indice minimo de altura a considerar
925 minIndex : valor de indice minimo de altura a considerar
918 maxIndex : valor de indice maximo de altura a considerar
926 maxIndex : valor de indice maximo de altura a considerar
919
927
920 Affected:
928 Affected:
921 self.dataOut.data_spc
929 self.dataOut.data_spc
922 self.dataOut.data_cspc
930 self.dataOut.data_cspc
923 self.dataOut.data_dc
931 self.dataOut.data_dc
924 self.dataOut.heightList
932 self.dataOut.heightList
925
933
926 Return:
934 Return:
927 1 si el metodo se ejecuto con exito caso contrario devuelve 0
935 1 si el metodo se ejecuto con exito caso contrario devuelve 0
928 """
936 """
929
937
930 if (minIndex < 0) or (minIndex > maxIndex):
938 if (minIndex < 0) or (minIndex > maxIndex):
931 raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
939 raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
932
940
933 if (maxIndex >= self.dataOut.nHeights):
941 if (maxIndex >= self.dataOut.nHeights):
934 maxIndex = self.dataOut.nHeights-1
942 maxIndex = self.dataOut.nHeights-1
935 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
943 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
936
944
937 nHeights = maxIndex - minIndex + 1
945 nHeights = maxIndex - minIndex + 1
938
946
939 #Spectra
947 #Spectra
940 data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
948 data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
941
949
942 data_cspc = None
950 data_cspc = None
943 if self.dataOut.data_cspc != None:
951 if self.dataOut.data_cspc != None:
944 data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
952 data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
945
953
946 data_dc = None
954 data_dc = None
947 if self.dataOut.data_dc != None:
955 if self.dataOut.data_dc != None:
948 data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
956 data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
949
957
950 self.dataOut.data_spc = data_spc
958 self.dataOut.data_spc = data_spc
951 self.dataOut.data_cspc = data_cspc
959 self.dataOut.data_cspc = data_cspc
952 self.dataOut.data_dc = data_dc
960 self.dataOut.data_dc = data_dc
953
961
954 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
962 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
955
963
956 return 1
964 return 1
957
965
958 def removeDC(self, mode = 1):
966 def removeDC(self, mode = 1):
959
967
960 dc_index = 0
968 dc_index = 0
961 freq_index = numpy.array([-2,-1,1,2])
969 freq_index = numpy.array([-2,-1,1,2])
962 data_spc = self.dataOut.data_spc
970 data_spc = self.dataOut.data_spc
963 data_cspc = self.dataOut.data_cspc
971 data_cspc = self.dataOut.data_cspc
964 data_dc = self.dataOut.data_dc
972 data_dc = self.dataOut.data_dc
965
973
966 if self.dataOut.flagShiftFFT:
974 if self.dataOut.flagShiftFFT:
967 dc_index += self.dataOut.nFFTPoints/2
975 dc_index += self.dataOut.nFFTPoints/2
968 freq_index += self.dataOut.nFFTPoints/2
976 freq_index += self.dataOut.nFFTPoints/2
969
977
970 if mode == 1:
978 if mode == 1:
971 data_spc[dc_index] = (data_spc[:,freq_index[1],:] + data_spc[:,freq_index[2],:])/2
979 data_spc[dc_index] = (data_spc[:,freq_index[1],:] + data_spc[:,freq_index[2],:])/2
972 if data_cspc != None:
980 if data_cspc != None:
973 data_cspc[dc_index] = (data_cspc[:,freq_index[1],:] + data_cspc[:,freq_index[2],:])/2
981 data_cspc[dc_index] = (data_cspc[:,freq_index[1],:] + data_cspc[:,freq_index[2],:])/2
974 return 1
982 return 1
975
983
976 if mode == 2:
984 if mode == 2:
977 pass
985 pass
978
986
979 if mode == 3:
987 if mode == 3:
980 pass
988 pass
981
989
982 raise ValueError, "mode parameter has to be 1, 2 or 3"
990 raise ValueError, "mode parameter has to be 1, 2 or 3"
983
991
984 def removeInterference(self):
992 def removeInterference(self):
985
993
986 pass
994 pass
987
995
988
996
989 class IncohInt(Operation):
997 class IncohInt(Operation):
990
998
991
999
992 __profIndex = 0
1000 __profIndex = 0
993 __withOverapping = False
1001 __withOverapping = False
994
1002
995 __byTime = False
1003 __byTime = False
996 __initime = None
1004 __initime = None
997 __lastdatatime = None
1005 __lastdatatime = None
998 __integrationtime = None
1006 __integrationtime = None
999
1007
1000 __buffer_spc = None
1008 __buffer_spc = None
1001 __buffer_cspc = None
1009 __buffer_cspc = None
1002 __buffer_dc = None
1010 __buffer_dc = None
1003
1011
1004 __dataReady = False
1012 __dataReady = False
1005
1013
1006 __timeInterval = None
1014 __timeInterval = None
1007
1015
1008 n = None
1016 n = None
1009
1017
1010
1018
1011
1019
1012 def __init__(self):
1020 def __init__(self):
1013
1021
1014 self.__isConfig = False
1022 self.__isConfig = False
1015
1023
1016 def setup(self, n=None, timeInterval=None, overlapping=False):
1024 def setup(self, n=None, timeInterval=None, overlapping=False):
1017 """
1025 """
1018 Set the parameters of the integration class.
1026 Set the parameters of the integration class.
1019
1027
1020 Inputs:
1028 Inputs:
1021
1029
1022 n : Number of coherent integrations
1030 n : Number of coherent integrations
1023 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
1031 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
1024 overlapping :
1032 overlapping :
1025
1033
1026 """
1034 """
1027
1035
1028 self.__initime = None
1036 self.__initime = None
1029 self.__lastdatatime = 0
1037 self.__lastdatatime = 0
1030 self.__buffer_spc = None
1038 self.__buffer_spc = None
1031 self.__buffer_cspc = None
1039 self.__buffer_cspc = None
1032 self.__buffer_dc = None
1040 self.__buffer_dc = None
1033 self.__dataReady = False
1041 self.__dataReady = False
1034
1042
1035
1043
1036 if n == None and timeInterval == None:
1044 if n == None and timeInterval == None:
1037 raise ValueError, "n or timeInterval should be specified ..."
1045 raise ValueError, "n or timeInterval should be specified ..."
1038
1046
1039 if n != None:
1047 if n != None:
1040 self.n = n
1048 self.n = n
1041 self.__byTime = False
1049 self.__byTime = False
1042 else:
1050 else:
1043 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
1051 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
1044 self.n = 9999
1052 self.n = 9999
1045 self.__byTime = True
1053 self.__byTime = True
1046
1054
1047 if overlapping:
1055 if overlapping:
1048 self.__withOverapping = True
1056 self.__withOverapping = True
1049 else:
1057 else:
1050 self.__withOverapping = False
1058 self.__withOverapping = False
1051 self.__buffer_spc = 0
1059 self.__buffer_spc = 0
1052 self.__buffer_cspc = 0
1060 self.__buffer_cspc = 0
1053 self.__buffer_dc = 0
1061 self.__buffer_dc = 0
1054
1062
1055 self.__profIndex = 0
1063 self.__profIndex = 0
1056
1064
1057 def putData(self, data_spc, data_cspc, data_dc):
1065 def putData(self, data_spc, data_cspc, data_dc):
1058
1066
1059 """
1067 """
1060 Add a profile to the __buffer_spc and increase in one the __profileIndex
1068 Add a profile to the __buffer_spc and increase in one the __profileIndex
1061
1069
1062 """
1070 """
1063
1071
1064 if not self.__withOverapping:
1072 if not self.__withOverapping:
1065 self.__buffer_spc += data_spc
1073 self.__buffer_spc += data_spc
1066
1074
1067 if data_cspc == None:
1075 if data_cspc == None:
1068 self.__buffer_cspc = None
1076 self.__buffer_cspc = None
1069 else:
1077 else:
1070 self.__buffer_cspc += data_cspc
1078 self.__buffer_cspc += data_cspc
1071
1079
1072 if data_dc == None:
1080 if data_dc == None:
1073 self.__buffer_dc = None
1081 self.__buffer_dc = None
1074 else:
1082 else:
1075 self.__buffer_dc += data_dc
1083 self.__buffer_dc += data_dc
1076
1084
1077 self.__profIndex += 1
1085 self.__profIndex += 1
1078 return
1086 return
1079
1087
1080 #Overlapping data
1088 #Overlapping data
1081 nChannels, nFFTPoints, nHeis = data_spc.shape
1089 nChannels, nFFTPoints, nHeis = data_spc.shape
1082 data_spc = numpy.reshape(data_spc, (1, nChannels, nFFTPoints, nHeis))
1090 data_spc = numpy.reshape(data_spc, (1, nChannels, nFFTPoints, nHeis))
1083 if data_cspc != None:
1091 if data_cspc != None:
1084 data_cspc = numpy.reshape(data_cspc, (1, -1, nFFTPoints, nHeis))
1092 data_cspc = numpy.reshape(data_cspc, (1, -1, nFFTPoints, nHeis))
1085 if data_dc != None:
1093 if data_dc != None:
1086 data_dc = numpy.reshape(data_dc, (1, -1, nHeis))
1094 data_dc = numpy.reshape(data_dc, (1, -1, nHeis))
1087
1095
1088 #If the buffer is empty then it takes the data value
1096 #If the buffer is empty then it takes the data value
1089 if self.__buffer_spc == None:
1097 if self.__buffer_spc == None:
1090 self.__buffer_spc = data_spc
1098 self.__buffer_spc = data_spc
1091
1099
1092 if data_cspc == None:
1100 if data_cspc == None:
1093 self.__buffer_cspc = None
1101 self.__buffer_cspc = None
1094 else:
1102 else:
1095 self.__buffer_cspc += data_cspc
1103 self.__buffer_cspc += data_cspc
1096
1104
1097 if data_dc == None:
1105 if data_dc == None:
1098 self.__buffer_dc = None
1106 self.__buffer_dc = None
1099 else:
1107 else:
1100 self.__buffer_dc += data_dc
1108 self.__buffer_dc += data_dc
1101
1109
1102 self.__profIndex += 1
1110 self.__profIndex += 1
1103 return
1111 return
1104
1112
1105 #If the buffer length is lower than n then stakcing the data value
1113 #If the buffer length is lower than n then stakcing the data value
1106 if self.__profIndex < self.n:
1114 if self.__profIndex < self.n:
1107 self.__buffer_spc = numpy.vstack((self.__buffer_spc, data_spc))
1115 self.__buffer_spc = numpy.vstack((self.__buffer_spc, data_spc))
1108
1116
1109 if data_cspc != None:
1117 if data_cspc != None:
1110 self.__buffer_cspc = numpy.vstack((self.__buffer_cspc, data_cspc))
1118 self.__buffer_cspc = numpy.vstack((self.__buffer_cspc, data_cspc))
1111
1119
1112 if data_dc != None:
1120 if data_dc != None:
1113 self.__buffer_dc = numpy.vstack((self.__buffer_dc, data_dc))
1121 self.__buffer_dc = numpy.vstack((self.__buffer_dc, data_dc))
1114
1122
1115 self.__profIndex += 1
1123 self.__profIndex += 1
1116 return
1124 return
1117
1125
1118 #If the buffer length is equal to n then replacing the last buffer value with the data value
1126 #If the buffer length is equal to n then replacing the last buffer value with the data value
1119 self.__buffer_spc = numpy.roll(self.__buffer_spc, -1, axis=0)
1127 self.__buffer_spc = numpy.roll(self.__buffer_spc, -1, axis=0)
1120 self.__buffer_spc[self.n-1] = data_spc
1128 self.__buffer_spc[self.n-1] = data_spc
1121
1129
1122 if data_cspc != None:
1130 if data_cspc != None:
1123 self.__buffer_cspc = numpy.roll(self.__buffer_cspc, -1, axis=0)
1131 self.__buffer_cspc = numpy.roll(self.__buffer_cspc, -1, axis=0)
1124 self.__buffer_cspc[self.n-1] = data_cspc
1132 self.__buffer_cspc[self.n-1] = data_cspc
1125
1133
1126 if data_dc != None:
1134 if data_dc != None:
1127 self.__buffer_dc = numpy.roll(self.__buffer_dc, -1, axis=0)
1135 self.__buffer_dc = numpy.roll(self.__buffer_dc, -1, axis=0)
1128 self.__buffer_dc[self.n-1] = data_dc
1136 self.__buffer_dc[self.n-1] = data_dc
1129
1137
1130 self.__profIndex = self.n
1138 self.__profIndex = self.n
1131 return
1139 return
1132
1140
1133
1141
1134 def pushData(self):
1142 def pushData(self):
1135 """
1143 """
1136 Return the sum of the last profiles and the profiles used in the sum.
1144 Return the sum of the last profiles and the profiles used in the sum.
1137
1145
1138 Affected:
1146 Affected:
1139
1147
1140 self.__profileIndex
1148 self.__profileIndex
1141
1149
1142 """
1150 """
1143 data_spc = None
1151 data_spc = None
1144 data_cspc = None
1152 data_cspc = None
1145 data_dc = None
1153 data_dc = None
1146
1154
1147 if not self.__withOverapping:
1155 if not self.__withOverapping:
1148 data_spc = self.__buffer_spc
1156 data_spc = self.__buffer_spc
1149 data_cspc = self.__buffer_cspc
1157 data_cspc = self.__buffer_cspc
1150 data_dc = self.__buffer_dc
1158 data_dc = self.__buffer_dc
1151
1159
1152 n = self.__profIndex
1160 n = self.__profIndex
1153
1161
1154 self.__buffer_spc = 0
1162 self.__buffer_spc = 0
1155 self.__buffer_cspc = 0
1163 self.__buffer_cspc = 0
1156 self.__buffer_dc = 0
1164 self.__buffer_dc = 0
1157 self.__profIndex = 0
1165 self.__profIndex = 0
1158
1166
1159 return data_spc, data_cspc, data_dc, n
1167 return data_spc, data_cspc, data_dc, n
1160
1168
1161 #Integration with Overlapping
1169 #Integration with Overlapping
1162 data_spc = numpy.sum(self.__buffer_spc, axis=0)
1170 data_spc = numpy.sum(self.__buffer_spc, axis=0)
1163
1171
1164 if self.__buffer_cspc != None:
1172 if self.__buffer_cspc != None:
1165 data_cspc = numpy.sum(self.__buffer_cspc, axis=0)
1173 data_cspc = numpy.sum(self.__buffer_cspc, axis=0)
1166
1174
1167 if self.__buffer_dc != None:
1175 if self.__buffer_dc != None:
1168 data_dc = numpy.sum(self.__buffer_dc, axis=0)
1176 data_dc = numpy.sum(self.__buffer_dc, axis=0)
1169
1177
1170 n = self.__profIndex
1178 n = self.__profIndex
1171
1179
1172 return data_spc, data_cspc, data_dc, n
1180 return data_spc, data_cspc, data_dc, n
1173
1181
1174 def byProfiles(self, *args):
1182 def byProfiles(self, *args):
1175
1183
1176 self.__dataReady = False
1184 self.__dataReady = False
1177 avgdata_spc = None
1185 avgdata_spc = None
1178 avgdata_cspc = None
1186 avgdata_cspc = None
1179 avgdata_dc = None
1187 avgdata_dc = None
1180 n = None
1188 n = None
1181
1189
1182 self.putData(*args)
1190 self.putData(*args)
1183
1191
1184 if self.__profIndex == self.n:
1192 if self.__profIndex == self.n:
1185
1193
1186 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1194 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1187 self.__dataReady = True
1195 self.__dataReady = True
1188
1196
1189 return avgdata_spc, avgdata_cspc, avgdata_dc
1197 return avgdata_spc, avgdata_cspc, avgdata_dc
1190
1198
1191 def byTime(self, datatime, *args):
1199 def byTime(self, datatime, *args):
1192
1200
1193 self.__dataReady = False
1201 self.__dataReady = False
1194 avgdata_spc = None
1202 avgdata_spc = None
1195 avgdata_cspc = None
1203 avgdata_cspc = None
1196 avgdata_dc = None
1204 avgdata_dc = None
1197 n = None
1205 n = None
1198
1206
1199 self.putData(*args)
1207 self.putData(*args)
1200
1208
1201 if (datatime - self.__initime) >= self.__integrationtime:
1209 if (datatime - self.__initime) >= self.__integrationtime:
1202 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1210 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1203 self.n = n
1211 self.n = n
1204 self.__dataReady = True
1212 self.__dataReady = True
1205
1213
1206 return avgdata_spc, avgdata_cspc, avgdata_dc
1214 return avgdata_spc, avgdata_cspc, avgdata_dc
1207
1215
1208 def integrate(self, datatime, *args):
1216 def integrate(self, datatime, *args):
1209
1217
1210 if self.__initime == None:
1218 if self.__initime == None:
1211 self.__initime = datatime
1219 self.__initime = datatime
1212
1220
1213 if self.__byTime:
1221 if self.__byTime:
1214 avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
1222 avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
1215 else:
1223 else:
1216 avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
1224 avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
1217
1225
1218 self.__lastdatatime = datatime
1226 self.__lastdatatime = datatime
1219
1227
1220 if avgdata_spc == None:
1228 if avgdata_spc == None:
1221 return None, None, None, None
1229 return None, None, None, None
1222
1230
1223 avgdatatime = self.__initime
1231 avgdatatime = self.__initime
1224 self.__timeInterval = (self.__lastdatatime - self.__initime)/(self.n - 1)
1232 self.__timeInterval = (self.__lastdatatime - self.__initime)/(self.n - 1)
1225
1233
1226 deltatime = datatime -self.__lastdatatime
1234 deltatime = datatime -self.__lastdatatime
1227
1235
1228 if not self.__withOverapping:
1236 if not self.__withOverapping:
1229 self.__initime = datatime
1237 self.__initime = datatime
1230 else:
1238 else:
1231 self.__initime += deltatime
1239 self.__initime += deltatime
1232
1240
1233 return avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc
1241 return avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc
1234
1242
1235 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
1243 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
1236
1244
1237 if not self.__isConfig:
1245 if not self.__isConfig:
1238 self.setup(n, timeInterval, overlapping)
1246 self.setup(n, timeInterval, overlapping)
1239 self.__isConfig = True
1247 self.__isConfig = True
1240
1248
1241 avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
1249 avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
1242 dataOut.data_spc,
1250 dataOut.data_spc,
1243 dataOut.data_cspc,
1251 dataOut.data_cspc,
1244 dataOut.data_dc)
1252 dataOut.data_dc)
1245
1253
1246 # dataOut.timeInterval *= n
1254 # dataOut.timeInterval *= n
1247 dataOut.flagNoData = True
1255 dataOut.flagNoData = True
1248
1256
1249 if self.__dataReady:
1257 if self.__dataReady:
1250
1258
1251 dataOut.data_spc = avgdata_spc
1259 dataOut.data_spc = avgdata_spc
1252 dataOut.data_cspc = avgdata_cspc
1260 dataOut.data_cspc = avgdata_cspc
1253 dataOut.data_dc = avgdata_dc
1261 dataOut.data_dc = avgdata_dc
1254
1262
1255 dataOut.nIncohInt *= self.n
1263 dataOut.nIncohInt *= self.n
1256 dataOut.utctime = avgdatatime
1264 dataOut.utctime = avgdatatime
1257 #dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints
1265 #dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints
1258 dataOut.timeInterval = self.__timeInterval*self.n
1266 dataOut.timeInterval = self.__timeInterval*self.n
1259 dataOut.flagNoData = False
1267 dataOut.flagNoData = False
1260
1268
1261 class ProfileSelector(Operation):
1269 class ProfileSelector(Operation):
1262
1270
1263 profileIndex = None
1271 profileIndex = None
1264 # Tamanho total de los perfiles
1272 # Tamanho total de los perfiles
1265 nProfiles = None
1273 nProfiles = None
1266
1274
1267 def __init__(self):
1275 def __init__(self):
1268
1276
1269 self.profileIndex = 0
1277 self.profileIndex = 0
1270
1278
1271 def incIndex(self):
1279 def incIndex(self):
1272 self.profileIndex += 1
1280 self.profileIndex += 1
1273
1281
1274 if self.profileIndex >= self.nProfiles:
1282 if self.profileIndex >= self.nProfiles:
1275 self.profileIndex = 0
1283 self.profileIndex = 0
1276
1284
1277 def isProfileInRange(self, minIndex, maxIndex):
1285 def isProfileInRange(self, minIndex, maxIndex):
1278
1286
1279 if self.profileIndex < minIndex:
1287 if self.profileIndex < minIndex:
1280 return False
1288 return False
1281
1289
1282 if self.profileIndex > maxIndex:
1290 if self.profileIndex > maxIndex:
1283 return False
1291 return False
1284
1292
1285 return True
1293 return True
1286
1294
1287 def isProfileInList(self, profileList):
1295 def isProfileInList(self, profileList):
1288
1296
1289 if self.profileIndex not in profileList:
1297 if self.profileIndex not in profileList:
1290 return False
1298 return False
1291
1299
1292 return True
1300 return True
1293
1301
1294 def run(self, dataOut, profileList=None, profileRangeList=None):
1302 def run(self, dataOut, profileList=None, profileRangeList=None):
1295
1303
1296 dataOut.flagNoData = True
1304 dataOut.flagNoData = True
1297 self.nProfiles = dataOut.nProfiles
1305 self.nProfiles = dataOut.nProfiles
1298
1306
1299 if profileList != None:
1307 if profileList != None:
1300 if self.isProfileInList(profileList):
1308 if self.isProfileInList(profileList):
1301 dataOut.flagNoData = False
1309 dataOut.flagNoData = False
1302
1310
1303 self.incIndex()
1311 self.incIndex()
1304 return 1
1312 return 1
1305
1313
1306
1314
1307 elif profileRangeList != None:
1315 elif profileRangeList != None:
1308 minIndex = profileRangeList[0]
1316 minIndex = profileRangeList[0]
1309 maxIndex = profileRangeList[1]
1317 maxIndex = profileRangeList[1]
1310 if self.isProfileInRange(minIndex, maxIndex):
1318 if self.isProfileInRange(minIndex, maxIndex):
1311 dataOut.flagNoData = False
1319 dataOut.flagNoData = False
1312
1320
1313 self.incIndex()
1321 self.incIndex()
1314 return 1
1322 return 1
1315
1323
1316 else:
1324 else:
1317 raise ValueError, "ProfileSelector needs profileList or profileRangeList"
1325 raise ValueError, "ProfileSelector needs profileList or profileRangeList"
1318
1326
1319 return 0
1327 return 0
1320
1328
General Comments 0
You need to be logged in to leave comments. Login now