##// END OF EJS Templates
schain
RSS
Test codificacion
Miguel Valdez -
r314:a179b84eeaa7
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1331 +1,1332
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
615 print "Freq0 ", time.time() - ini
616
616
617 fft_data = numpy.fft.fft(data, axis=1)
617 fft_data = numpy.fft.fft(data, axis=1)
618
618
619 print "Freq1 ", time.time() - ini
619 print "Freq1 ", time.time() - ini
620
620
621 conv = fft_data*fft_code
621 conv = fft_data*fft_code
622
622
623 print "Freq2 ", time.time() - ini
623 print "Freq2 ", time.time() - ini
624
624
625 data = numpy.fft.ifft(conv,axis=1)
625 data = numpy.fft.ifft(conv,axis=1)
626
626
627 print "Freq3 ", time.time() - ini
627 print "Freq3 ", time.time() - ini
628
628
629 datadec = data[:,:-self.nBaud+1]
629 datadec = data[:,:-self.nBaud+1]
630
630
631 print "Freq4 ", time.time() - ini
631 print "Freq4 ", time.time() - ini
632
632
633 return datadec
633 return datadec
634
634
635 def convolutionInFreqOpt(self, data):
635 def convolutionInFreqOpt(self, data):
636
636
637 ini = time.time()
637 ini = time.time()
638
638
639 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
639 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
640
640
641 data = cfunctions.decoder(fft_code, data)
641 data = cfunctions.decoder(fft_code, data)
642
642
643 datadec = data[:,:-self.nBaud+1]
643 datadec = data[:,:-self.nBaud+1]
644
644
645 print "OptFreq ", time.time() - ini
645 print "OptFreq ", time.time() - ini
646
646
647 return datadec
647 return datadec
648
648
649 def convolutionInTime(self, data):
649 def convolutionInTime(self, data):
650
650
651 ini = time.time()
651 ini = time.time()
652 print self.datadecTime.shape, data.shape, code.shape
653
652
654 code = self.code[self.__profIndex].reshape(1,-1)
653 code = self.code[self.__profIndex].reshape(1,-1)
655
654
655 print self.datadecTime.shape, data.shape, code.shape
656
656 for i in range(self.__nChannels):
657 for i in range(self.__nChannels):
657 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='valid')
658 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='valid')
658
659
659 print "Time ", time.time() - ini
660 print "Time ", time.time() - ini
660
661
661 return self.datadecTime
662 return self.datadecTime
662
663
663 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0):
664 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0):
664 ini = time.time()
665 ini = time.time()
665 if not self.__isConfig:
666 if not self.__isConfig:
666
667
667 if code == None:
668 if code == None:
668 code = dataOut.code
669 code = dataOut.code
669 else:
670 else:
670 code = numpy.array(code).reshape(nCode,nBaud)
671 code = numpy.array(code).reshape(nCode,nBaud)
671 dataOut.code = code
672 dataOut.code = code
672 dataOut.nCode = nCode
673 dataOut.nCode = nCode
673 dataOut.nBaud = nBaud
674 dataOut.nBaud = nBaud
674
675
675 if code == None:
676 if code == None:
676 return 1
677 return 1
677
678
678 self.setup(code, dataOut.data.shape)
679 self.setup(code, dataOut.data.shape)
679 self.__isConfig = True
680 self.__isConfig = True
680
681
681 print "DAta shape ", dataOut.data.shape
682 print "DAta shape ", dataOut.data.shape
682
683
683 if mode == 0:
684 if mode == 0:
684 datadec = self.convolutionInFreq(dataOut.data)
685 datadec = self.convolutionInFreq(dataOut.data)
685
686
686 if mode == 1:
687 if mode == 1:
687 datadec = self.convolutionInTime(dataOut.data)
688 datadec = self.convolutionInTime(dataOut.data)
688
689
689 if mode == 2:
690 if mode == 2:
690 datadec = self.convolutionInFreqOpt(dataOut.data)
691 datadec = self.convolutionInFreqOpt(dataOut.data)
691
692
692 dataOut.data = datadec
693 dataOut.data = datadec
693
694
694 dataOut.heightList = dataOut.heightList[0:self.ndatadec]
695 dataOut.heightList = dataOut.heightList[0:self.ndatadec]
695
696
696 dataOut.flagDecodeData = True #asumo q la data no esta decodificada
697 dataOut.flagDecodeData = True #asumo q la data no esta decodificada
697
698
698 print time.time() - ini, "prof = %d, nCode=%d" %(self.__profIndex, self.nCode)
699 print time.time() - ini, "prof = %d, nCode=%d" %(self.__profIndex, self.nCode)
699
700
700 if self.__profIndex == self.nCode-1:
701 if self.__profIndex == self.nCode-1:
701 self.__profIndex = 0
702 self.__profIndex = 0
702 return 1
703 return 1
703
704
704 self.__profIndex += 1
705 self.__profIndex += 1
705
706
706 return 1
707 return 1
707 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
708 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
708
709
709
710
710
711
711 class SpectraProc(ProcessingUnit):
712 class SpectraProc(ProcessingUnit):
712
713
713 def __init__(self):
714 def __init__(self):
714
715
715 self.objectDict = {}
716 self.objectDict = {}
716 self.buffer = None
717 self.buffer = None
717 self.firstdatatime = None
718 self.firstdatatime = None
718 self.profIndex = 0
719 self.profIndex = 0
719 self.dataOut = Spectra()
720 self.dataOut = Spectra()
720
721
721 def __updateObjFromInput(self):
722 def __updateObjFromInput(self):
722
723
723 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
724 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
724 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
725 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
725 self.dataOut.channelList = self.dataIn.channelList
726 self.dataOut.channelList = self.dataIn.channelList
726 self.dataOut.heightList = self.dataIn.heightList
727 self.dataOut.heightList = self.dataIn.heightList
727 self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
728 self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
728 # self.dataOut.nHeights = self.dataIn.nHeights
729 # self.dataOut.nHeights = self.dataIn.nHeights
729 # self.dataOut.nChannels = self.dataIn.nChannels
730 # self.dataOut.nChannels = self.dataIn.nChannels
730 self.dataOut.nBaud = self.dataIn.nBaud
731 self.dataOut.nBaud = self.dataIn.nBaud
731 self.dataOut.nCode = self.dataIn.nCode
732 self.dataOut.nCode = self.dataIn.nCode
732 self.dataOut.code = self.dataIn.code
733 self.dataOut.code = self.dataIn.code
733 self.dataOut.nProfiles = self.dataOut.nFFTPoints
734 self.dataOut.nProfiles = self.dataOut.nFFTPoints
734 # self.dataOut.channelIndexList = self.dataIn.channelIndexList
735 # self.dataOut.channelIndexList = self.dataIn.channelIndexList
735 self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
736 self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
736 self.dataOut.utctime = self.firstdatatime
737 self.dataOut.utctime = self.firstdatatime
737 self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
738 self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
738 self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
739 self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
739 self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
740 self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
740 self.dataOut.nCohInt = self.dataIn.nCohInt
741 self.dataOut.nCohInt = self.dataIn.nCohInt
741 self.dataOut.nIncohInt = 1
742 self.dataOut.nIncohInt = 1
742 self.dataOut.ippSeconds = self.dataIn.ippSeconds
743 self.dataOut.ippSeconds = self.dataIn.ippSeconds
743 self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
744 self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
744
745
745 self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
746 self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
746
747
747 def __getFft(self):
748 def __getFft(self):
748 """
749 """
749 Convierte valores de Voltaje a Spectra
750 Convierte valores de Voltaje a Spectra
750
751
751 Affected:
752 Affected:
752 self.dataOut.data_spc
753 self.dataOut.data_spc
753 self.dataOut.data_cspc
754 self.dataOut.data_cspc
754 self.dataOut.data_dc
755 self.dataOut.data_dc
755 self.dataOut.heightList
756 self.dataOut.heightList
756 self.profIndex
757 self.profIndex
757 self.buffer
758 self.buffer
758 self.dataOut.flagNoData
759 self.dataOut.flagNoData
759 """
760 """
760 fft_volt = numpy.fft.fft(self.buffer,axis=1)
761 fft_volt = numpy.fft.fft(self.buffer,axis=1)
761 fft_volt = fft_volt.astype(numpy.dtype('complex'))
762 fft_volt = fft_volt.astype(numpy.dtype('complex'))
762 dc = fft_volt[:,0,:]
763 dc = fft_volt[:,0,:]
763
764
764 #calculo de self-spectra
765 #calculo de self-spectra
765 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
766 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
766 spc = fft_volt * numpy.conjugate(fft_volt)
767 spc = fft_volt * numpy.conjugate(fft_volt)
767 spc = spc.real
768 spc = spc.real
768
769
769 blocksize = 0
770 blocksize = 0
770 blocksize += dc.size
771 blocksize += dc.size
771 blocksize += spc.size
772 blocksize += spc.size
772
773
773 cspc = None
774 cspc = None
774 pairIndex = 0
775 pairIndex = 0
775 if self.dataOut.pairsList != None:
776 if self.dataOut.pairsList != None:
776 #calculo de cross-spectra
777 #calculo de cross-spectra
777 cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
778 cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
778 for pair in self.dataOut.pairsList:
779 for pair in self.dataOut.pairsList:
779 cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
780 cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
780 pairIndex += 1
781 pairIndex += 1
781 blocksize += cspc.size
782 blocksize += cspc.size
782
783
783 self.dataOut.data_spc = spc
784 self.dataOut.data_spc = spc
784 self.dataOut.data_cspc = cspc
785 self.dataOut.data_cspc = cspc
785 self.dataOut.data_dc = dc
786 self.dataOut.data_dc = dc
786 self.dataOut.blockSize = blocksize
787 self.dataOut.blockSize = blocksize
787
788
788 def init(self, nFFTPoints=None, pairsList=None):
789 def init(self, nFFTPoints=None, pairsList=None):
789
790
790 self.dataOut.flagNoData = True
791 self.dataOut.flagNoData = True
791
792
792 if self.dataIn.type == "Spectra":
793 if self.dataIn.type == "Spectra":
793 self.dataOut.copy(self.dataIn)
794 self.dataOut.copy(self.dataIn)
794 return
795 return
795
796
796 if self.dataIn.type == "Voltage":
797 if self.dataIn.type == "Voltage":
797
798
798 if nFFTPoints == None:
799 if nFFTPoints == None:
799 raise ValueError, "This SpectraProc.init() need nFFTPoints input variable"
800 raise ValueError, "This SpectraProc.init() need nFFTPoints input variable"
800
801
801 if pairsList == None:
802 if pairsList == None:
802 nPairs = 0
803 nPairs = 0
803 else:
804 else:
804 nPairs = len(pairsList)
805 nPairs = len(pairsList)
805
806
806 self.dataOut.nFFTPoints = nFFTPoints
807 self.dataOut.nFFTPoints = nFFTPoints
807 self.dataOut.pairsList = pairsList
808 self.dataOut.pairsList = pairsList
808 self.dataOut.nPairs = nPairs
809 self.dataOut.nPairs = nPairs
809
810
810 if self.buffer == None:
811 if self.buffer == None:
811 self.buffer = numpy.zeros((self.dataIn.nChannels,
812 self.buffer = numpy.zeros((self.dataIn.nChannels,
812 self.dataOut.nFFTPoints,
813 self.dataOut.nFFTPoints,
813 self.dataIn.nHeights),
814 self.dataIn.nHeights),
814 dtype='complex')
815 dtype='complex')
815
816
816
817
817 self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
818 self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
818 self.profIndex += 1
819 self.profIndex += 1
819
820
820 if self.firstdatatime == None:
821 if self.firstdatatime == None:
821 self.firstdatatime = self.dataIn.utctime
822 self.firstdatatime = self.dataIn.utctime
822
823
823 if self.profIndex == self.dataOut.nFFTPoints:
824 if self.profIndex == self.dataOut.nFFTPoints:
824 self.__updateObjFromInput()
825 self.__updateObjFromInput()
825 self.__getFft()
826 self.__getFft()
826
827
827 self.dataOut.flagNoData = False
828 self.dataOut.flagNoData = False
828
829
829 self.buffer = None
830 self.buffer = None
830 self.firstdatatime = None
831 self.firstdatatime = None
831 self.profIndex = 0
832 self.profIndex = 0
832
833
833 return
834 return
834
835
835 raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
836 raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
836
837
837 def selectChannels(self, channelList):
838 def selectChannels(self, channelList):
838
839
839 channelIndexList = []
840 channelIndexList = []
840
841
841 for channel in channelList:
842 for channel in channelList:
842 index = self.dataOut.channelList.index(channel)
843 index = self.dataOut.channelList.index(channel)
843 channelIndexList.append(index)
844 channelIndexList.append(index)
844
845
845 self.selectChannelsByIndex(channelIndexList)
846 self.selectChannelsByIndex(channelIndexList)
846
847
847 def selectChannelsByIndex(self, channelIndexList):
848 def selectChannelsByIndex(self, channelIndexList):
848 """
849 """
849 Selecciona un bloque de datos en base a canales segun el channelIndexList
850 Selecciona un bloque de datos en base a canales segun el channelIndexList
850
851
851 Input:
852 Input:
852 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
853 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
853
854
854 Affected:
855 Affected:
855 self.dataOut.data_spc
856 self.dataOut.data_spc
856 self.dataOut.channelIndexList
857 self.dataOut.channelIndexList
857 self.dataOut.nChannels
858 self.dataOut.nChannels
858
859
859 Return:
860 Return:
860 None
861 None
861 """
862 """
862
863
863 for channelIndex in channelIndexList:
864 for channelIndex in channelIndexList:
864 if channelIndex not in self.dataOut.channelIndexList:
865 if channelIndex not in self.dataOut.channelIndexList:
865 print channelIndexList
866 print channelIndexList
866 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
867 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
867
868
868 nChannels = len(channelIndexList)
869 nChannels = len(channelIndexList)
869
870
870 data_spc = self.dataOut.data_spc[channelIndexList,:]
871 data_spc = self.dataOut.data_spc[channelIndexList,:]
871
872
872 self.dataOut.data_spc = data_spc
873 self.dataOut.data_spc = data_spc
873 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
874 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
874 # self.dataOut.nChannels = nChannels
875 # self.dataOut.nChannels = nChannels
875
876
876 return 1
877 return 1
877
878
878 def selectHeights(self, minHei, maxHei):
879 def selectHeights(self, minHei, maxHei):
879 """
880 """
880 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
881 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
881 minHei <= height <= maxHei
882 minHei <= height <= maxHei
882
883
883 Input:
884 Input:
884 minHei : valor minimo de altura a considerar
885 minHei : valor minimo de altura a considerar
885 maxHei : valor maximo de altura a considerar
886 maxHei : valor maximo de altura a considerar
886
887
887 Affected:
888 Affected:
888 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
889 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
889
890
890 Return:
891 Return:
891 1 si el metodo se ejecuto con exito caso contrario devuelve 0
892 1 si el metodo se ejecuto con exito caso contrario devuelve 0
892 """
893 """
893 if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
894 if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
894 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)
895
896
896 if (maxHei > self.dataOut.heightList[-1]):
897 if (maxHei > self.dataOut.heightList[-1]):
897 maxHei = self.dataOut.heightList[-1]
898 maxHei = self.dataOut.heightList[-1]
898 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
899 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
899
900
900 minIndex = 0
901 minIndex = 0
901 maxIndex = 0
902 maxIndex = 0
902 heights = self.dataOut.heightList
903 heights = self.dataOut.heightList
903
904
904 inda = numpy.where(heights >= minHei)
905 inda = numpy.where(heights >= minHei)
905 indb = numpy.where(heights <= maxHei)
906 indb = numpy.where(heights <= maxHei)
906
907
907 try:
908 try:
908 minIndex = inda[0][0]
909 minIndex = inda[0][0]
909 except:
910 except:
910 minIndex = 0
911 minIndex = 0
911
912
912 try:
913 try:
913 maxIndex = indb[0][-1]
914 maxIndex = indb[0][-1]
914 except:
915 except:
915 maxIndex = len(heights)
916 maxIndex = len(heights)
916
917
917 self.selectHeightsByIndex(minIndex, maxIndex)
918 self.selectHeightsByIndex(minIndex, maxIndex)
918
919
919 return 1
920 return 1
920
921
921
922
922 def selectHeightsByIndex(self, minIndex, maxIndex):
923 def selectHeightsByIndex(self, minIndex, maxIndex):
923 """
924 """
924 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
925 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
925 minIndex <= index <= maxIndex
926 minIndex <= index <= maxIndex
926
927
927 Input:
928 Input:
928 minIndex : valor de indice minimo de altura a considerar
929 minIndex : valor de indice minimo de altura a considerar
929 maxIndex : valor de indice maximo de altura a considerar
930 maxIndex : valor de indice maximo de altura a considerar
930
931
931 Affected:
932 Affected:
932 self.dataOut.data_spc
933 self.dataOut.data_spc
933 self.dataOut.data_cspc
934 self.dataOut.data_cspc
934 self.dataOut.data_dc
935 self.dataOut.data_dc
935 self.dataOut.heightList
936 self.dataOut.heightList
936
937
937 Return:
938 Return:
938 1 si el metodo se ejecuto con exito caso contrario devuelve 0
939 1 si el metodo se ejecuto con exito caso contrario devuelve 0
939 """
940 """
940
941
941 if (minIndex < 0) or (minIndex > maxIndex):
942 if (minIndex < 0) or (minIndex > maxIndex):
942 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)
943
944
944 if (maxIndex >= self.dataOut.nHeights):
945 if (maxIndex >= self.dataOut.nHeights):
945 maxIndex = self.dataOut.nHeights-1
946 maxIndex = self.dataOut.nHeights-1
946 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
947 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
947
948
948 nHeights = maxIndex - minIndex + 1
949 nHeights = maxIndex - minIndex + 1
949
950
950 #Spectra
951 #Spectra
951 data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
952 data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
952
953
953 data_cspc = None
954 data_cspc = None
954 if self.dataOut.data_cspc != None:
955 if self.dataOut.data_cspc != None:
955 data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
956 data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
956
957
957 data_dc = None
958 data_dc = None
958 if self.dataOut.data_dc != None:
959 if self.dataOut.data_dc != None:
959 data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
960 data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
960
961
961 self.dataOut.data_spc = data_spc
962 self.dataOut.data_spc = data_spc
962 self.dataOut.data_cspc = data_cspc
963 self.dataOut.data_cspc = data_cspc
963 self.dataOut.data_dc = data_dc
964 self.dataOut.data_dc = data_dc
964
965
965 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
966 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
966
967
967 return 1
968 return 1
968
969
969 def removeDC(self, mode = 1):
970 def removeDC(self, mode = 1):
970
971
971 dc_index = 0
972 dc_index = 0
972 freq_index = numpy.array([-2,-1,1,2])
973 freq_index = numpy.array([-2,-1,1,2])
973 data_spc = self.dataOut.data_spc
974 data_spc = self.dataOut.data_spc
974 data_cspc = self.dataOut.data_cspc
975 data_cspc = self.dataOut.data_cspc
975 data_dc = self.dataOut.data_dc
976 data_dc = self.dataOut.data_dc
976
977
977 if self.dataOut.flagShiftFFT:
978 if self.dataOut.flagShiftFFT:
978 dc_index += self.dataOut.nFFTPoints/2
979 dc_index += self.dataOut.nFFTPoints/2
979 freq_index += self.dataOut.nFFTPoints/2
980 freq_index += self.dataOut.nFFTPoints/2
980
981
981 if mode == 1:
982 if mode == 1:
982 data_spc[dc_index] = (data_spc[:,freq_index[1],:] + data_spc[:,freq_index[2],:])/2
983 data_spc[dc_index] = (data_spc[:,freq_index[1],:] + data_spc[:,freq_index[2],:])/2
983 if data_cspc != None:
984 if data_cspc != None:
984 data_cspc[dc_index] = (data_cspc[:,freq_index[1],:] + data_cspc[:,freq_index[2],:])/2
985 data_cspc[dc_index] = (data_cspc[:,freq_index[1],:] + data_cspc[:,freq_index[2],:])/2
985 return 1
986 return 1
986
987
987 if mode == 2:
988 if mode == 2:
988 pass
989 pass
989
990
990 if mode == 3:
991 if mode == 3:
991 pass
992 pass
992
993
993 raise ValueError, "mode parameter has to be 1, 2 or 3"
994 raise ValueError, "mode parameter has to be 1, 2 or 3"
994
995
995 def removeInterference(self):
996 def removeInterference(self):
996
997
997 pass
998 pass
998
999
999
1000
1000 class IncohInt(Operation):
1001 class IncohInt(Operation):
1001
1002
1002
1003
1003 __profIndex = 0
1004 __profIndex = 0
1004 __withOverapping = False
1005 __withOverapping = False
1005
1006
1006 __byTime = False
1007 __byTime = False
1007 __initime = None
1008 __initime = None
1008 __lastdatatime = None
1009 __lastdatatime = None
1009 __integrationtime = None
1010 __integrationtime = None
1010
1011
1011 __buffer_spc = None
1012 __buffer_spc = None
1012 __buffer_cspc = None
1013 __buffer_cspc = None
1013 __buffer_dc = None
1014 __buffer_dc = None
1014
1015
1015 __dataReady = False
1016 __dataReady = False
1016
1017
1017 __timeInterval = None
1018 __timeInterval = None
1018
1019
1019 n = None
1020 n = None
1020
1021
1021
1022
1022
1023
1023 def __init__(self):
1024 def __init__(self):
1024
1025
1025 self.__isConfig = False
1026 self.__isConfig = False
1026
1027
1027 def setup(self, n=None, timeInterval=None, overlapping=False):
1028 def setup(self, n=None, timeInterval=None, overlapping=False):
1028 """
1029 """
1029 Set the parameters of the integration class.
1030 Set the parameters of the integration class.
1030
1031
1031 Inputs:
1032 Inputs:
1032
1033
1033 n : Number of coherent integrations
1034 n : Number of coherent integrations
1034 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
1035 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
1035 overlapping :
1036 overlapping :
1036
1037
1037 """
1038 """
1038
1039
1039 self.__initime = None
1040 self.__initime = None
1040 self.__lastdatatime = 0
1041 self.__lastdatatime = 0
1041 self.__buffer_spc = None
1042 self.__buffer_spc = None
1042 self.__buffer_cspc = None
1043 self.__buffer_cspc = None
1043 self.__buffer_dc = None
1044 self.__buffer_dc = None
1044 self.__dataReady = False
1045 self.__dataReady = False
1045
1046
1046
1047
1047 if n == None and timeInterval == None:
1048 if n == None and timeInterval == None:
1048 raise ValueError, "n or timeInterval should be specified ..."
1049 raise ValueError, "n or timeInterval should be specified ..."
1049
1050
1050 if n != None:
1051 if n != None:
1051 self.n = n
1052 self.n = n
1052 self.__byTime = False
1053 self.__byTime = False
1053 else:
1054 else:
1054 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
1055 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
1055 self.n = 9999
1056 self.n = 9999
1056 self.__byTime = True
1057 self.__byTime = True
1057
1058
1058 if overlapping:
1059 if overlapping:
1059 self.__withOverapping = True
1060 self.__withOverapping = True
1060 else:
1061 else:
1061 self.__withOverapping = False
1062 self.__withOverapping = False
1062 self.__buffer_spc = 0
1063 self.__buffer_spc = 0
1063 self.__buffer_cspc = 0
1064 self.__buffer_cspc = 0
1064 self.__buffer_dc = 0
1065 self.__buffer_dc = 0
1065
1066
1066 self.__profIndex = 0
1067 self.__profIndex = 0
1067
1068
1068 def putData(self, data_spc, data_cspc, data_dc):
1069 def putData(self, data_spc, data_cspc, data_dc):
1069
1070
1070 """
1071 """
1071 Add a profile to the __buffer_spc and increase in one the __profileIndex
1072 Add a profile to the __buffer_spc and increase in one the __profileIndex
1072
1073
1073 """
1074 """
1074
1075
1075 if not self.__withOverapping:
1076 if not self.__withOverapping:
1076 self.__buffer_spc += data_spc
1077 self.__buffer_spc += data_spc
1077
1078
1078 if data_cspc == None:
1079 if data_cspc == None:
1079 self.__buffer_cspc = None
1080 self.__buffer_cspc = None
1080 else:
1081 else:
1081 self.__buffer_cspc += data_cspc
1082 self.__buffer_cspc += data_cspc
1082
1083
1083 if data_dc == None:
1084 if data_dc == None:
1084 self.__buffer_dc = None
1085 self.__buffer_dc = None
1085 else:
1086 else:
1086 self.__buffer_dc += data_dc
1087 self.__buffer_dc += data_dc
1087
1088
1088 self.__profIndex += 1
1089 self.__profIndex += 1
1089 return
1090 return
1090
1091
1091 #Overlapping data
1092 #Overlapping data
1092 nChannels, nFFTPoints, nHeis = data_spc.shape
1093 nChannels, nFFTPoints, nHeis = data_spc.shape
1093 data_spc = numpy.reshape(data_spc, (1, nChannels, nFFTPoints, nHeis))
1094 data_spc = numpy.reshape(data_spc, (1, nChannels, nFFTPoints, nHeis))
1094 if data_cspc != None:
1095 if data_cspc != None:
1095 data_cspc = numpy.reshape(data_cspc, (1, -1, nFFTPoints, nHeis))
1096 data_cspc = numpy.reshape(data_cspc, (1, -1, nFFTPoints, nHeis))
1096 if data_dc != None:
1097 if data_dc != None:
1097 data_dc = numpy.reshape(data_dc, (1, -1, nHeis))
1098 data_dc = numpy.reshape(data_dc, (1, -1, nHeis))
1098
1099
1099 #If the buffer is empty then it takes the data value
1100 #If the buffer is empty then it takes the data value
1100 if self.__buffer_spc == None:
1101 if self.__buffer_spc == None:
1101 self.__buffer_spc = data_spc
1102 self.__buffer_spc = data_spc
1102
1103
1103 if data_cspc == None:
1104 if data_cspc == None:
1104 self.__buffer_cspc = None
1105 self.__buffer_cspc = None
1105 else:
1106 else:
1106 self.__buffer_cspc += data_cspc
1107 self.__buffer_cspc += data_cspc
1107
1108
1108 if data_dc == None:
1109 if data_dc == None:
1109 self.__buffer_dc = None
1110 self.__buffer_dc = None
1110 else:
1111 else:
1111 self.__buffer_dc += data_dc
1112 self.__buffer_dc += data_dc
1112
1113
1113 self.__profIndex += 1
1114 self.__profIndex += 1
1114 return
1115 return
1115
1116
1116 #If the buffer length is lower than n then stakcing the data value
1117 #If the buffer length is lower than n then stakcing the data value
1117 if self.__profIndex < self.n:
1118 if self.__profIndex < self.n:
1118 self.__buffer_spc = numpy.vstack((self.__buffer_spc, data_spc))
1119 self.__buffer_spc = numpy.vstack((self.__buffer_spc, data_spc))
1119
1120
1120 if data_cspc != None:
1121 if data_cspc != None:
1121 self.__buffer_cspc = numpy.vstack((self.__buffer_cspc, data_cspc))
1122 self.__buffer_cspc = numpy.vstack((self.__buffer_cspc, data_cspc))
1122
1123
1123 if data_dc != None:
1124 if data_dc != None:
1124 self.__buffer_dc = numpy.vstack((self.__buffer_dc, data_dc))
1125 self.__buffer_dc = numpy.vstack((self.__buffer_dc, data_dc))
1125
1126
1126 self.__profIndex += 1
1127 self.__profIndex += 1
1127 return
1128 return
1128
1129
1129 #If the buffer length is equal to n then replacing the last buffer value with the data value
1130 #If the buffer length is equal to n then replacing the last buffer value with the data value
1130 self.__buffer_spc = numpy.roll(self.__buffer_spc, -1, axis=0)
1131 self.__buffer_spc = numpy.roll(self.__buffer_spc, -1, axis=0)
1131 self.__buffer_spc[self.n-1] = data_spc
1132 self.__buffer_spc[self.n-1] = data_spc
1132
1133
1133 if data_cspc != None:
1134 if data_cspc != None:
1134 self.__buffer_cspc = numpy.roll(self.__buffer_cspc, -1, axis=0)
1135 self.__buffer_cspc = numpy.roll(self.__buffer_cspc, -1, axis=0)
1135 self.__buffer_cspc[self.n-1] = data_cspc
1136 self.__buffer_cspc[self.n-1] = data_cspc
1136
1137
1137 if data_dc != None:
1138 if data_dc != None:
1138 self.__buffer_dc = numpy.roll(self.__buffer_dc, -1, axis=0)
1139 self.__buffer_dc = numpy.roll(self.__buffer_dc, -1, axis=0)
1139 self.__buffer_dc[self.n-1] = data_dc
1140 self.__buffer_dc[self.n-1] = data_dc
1140
1141
1141 self.__profIndex = self.n
1142 self.__profIndex = self.n
1142 return
1143 return
1143
1144
1144
1145
1145 def pushData(self):
1146 def pushData(self):
1146 """
1147 """
1147 Return the sum of the last profiles and the profiles used in the sum.
1148 Return the sum of the last profiles and the profiles used in the sum.
1148
1149
1149 Affected:
1150 Affected:
1150
1151
1151 self.__profileIndex
1152 self.__profileIndex
1152
1153
1153 """
1154 """
1154 data_spc = None
1155 data_spc = None
1155 data_cspc = None
1156 data_cspc = None
1156 data_dc = None
1157 data_dc = None
1157
1158
1158 if not self.__withOverapping:
1159 if not self.__withOverapping:
1159 data_spc = self.__buffer_spc
1160 data_spc = self.__buffer_spc
1160 data_cspc = self.__buffer_cspc
1161 data_cspc = self.__buffer_cspc
1161 data_dc = self.__buffer_dc
1162 data_dc = self.__buffer_dc
1162
1163
1163 n = self.__profIndex
1164 n = self.__profIndex
1164
1165
1165 self.__buffer_spc = 0
1166 self.__buffer_spc = 0
1166 self.__buffer_cspc = 0
1167 self.__buffer_cspc = 0
1167 self.__buffer_dc = 0
1168 self.__buffer_dc = 0
1168 self.__profIndex = 0
1169 self.__profIndex = 0
1169
1170
1170 return data_spc, data_cspc, data_dc, n
1171 return data_spc, data_cspc, data_dc, n
1171
1172
1172 #Integration with Overlapping
1173 #Integration with Overlapping
1173 data_spc = numpy.sum(self.__buffer_spc, axis=0)
1174 data_spc = numpy.sum(self.__buffer_spc, axis=0)
1174
1175
1175 if self.__buffer_cspc != None:
1176 if self.__buffer_cspc != None:
1176 data_cspc = numpy.sum(self.__buffer_cspc, axis=0)
1177 data_cspc = numpy.sum(self.__buffer_cspc, axis=0)
1177
1178
1178 if self.__buffer_dc != None:
1179 if self.__buffer_dc != None:
1179 data_dc = numpy.sum(self.__buffer_dc, axis=0)
1180 data_dc = numpy.sum(self.__buffer_dc, axis=0)
1180
1181
1181 n = self.__profIndex
1182 n = self.__profIndex
1182
1183
1183 return data_spc, data_cspc, data_dc, n
1184 return data_spc, data_cspc, data_dc, n
1184
1185
1185 def byProfiles(self, *args):
1186 def byProfiles(self, *args):
1186
1187
1187 self.__dataReady = False
1188 self.__dataReady = False
1188 avgdata_spc = None
1189 avgdata_spc = None
1189 avgdata_cspc = None
1190 avgdata_cspc = None
1190 avgdata_dc = None
1191 avgdata_dc = None
1191 n = None
1192 n = None
1192
1193
1193 self.putData(*args)
1194 self.putData(*args)
1194
1195
1195 if self.__profIndex == self.n:
1196 if self.__profIndex == self.n:
1196
1197
1197 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1198 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1198 self.__dataReady = True
1199 self.__dataReady = True
1199
1200
1200 return avgdata_spc, avgdata_cspc, avgdata_dc
1201 return avgdata_spc, avgdata_cspc, avgdata_dc
1201
1202
1202 def byTime(self, datatime, *args):
1203 def byTime(self, datatime, *args):
1203
1204
1204 self.__dataReady = False
1205 self.__dataReady = False
1205 avgdata_spc = None
1206 avgdata_spc = None
1206 avgdata_cspc = None
1207 avgdata_cspc = None
1207 avgdata_dc = None
1208 avgdata_dc = None
1208 n = None
1209 n = None
1209
1210
1210 self.putData(*args)
1211 self.putData(*args)
1211
1212
1212 if (datatime - self.__initime) >= self.__integrationtime:
1213 if (datatime - self.__initime) >= self.__integrationtime:
1213 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1214 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1214 self.n = n
1215 self.n = n
1215 self.__dataReady = True
1216 self.__dataReady = True
1216
1217
1217 return avgdata_spc, avgdata_cspc, avgdata_dc
1218 return avgdata_spc, avgdata_cspc, avgdata_dc
1218
1219
1219 def integrate(self, datatime, *args):
1220 def integrate(self, datatime, *args):
1220
1221
1221 if self.__initime == None:
1222 if self.__initime == None:
1222 self.__initime = datatime
1223 self.__initime = datatime
1223
1224
1224 if self.__byTime:
1225 if self.__byTime:
1225 avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
1226 avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
1226 else:
1227 else:
1227 avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
1228 avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
1228
1229
1229 self.__lastdatatime = datatime
1230 self.__lastdatatime = datatime
1230
1231
1231 if avgdata_spc == None:
1232 if avgdata_spc == None:
1232 return None, None, None, None
1233 return None, None, None, None
1233
1234
1234 avgdatatime = self.__initime
1235 avgdatatime = self.__initime
1235 self.__timeInterval = (self.__lastdatatime - self.__initime)/(self.n - 1)
1236 self.__timeInterval = (self.__lastdatatime - self.__initime)/(self.n - 1)
1236
1237
1237 deltatime = datatime -self.__lastdatatime
1238 deltatime = datatime -self.__lastdatatime
1238
1239
1239 if not self.__withOverapping:
1240 if not self.__withOverapping:
1240 self.__initime = datatime
1241 self.__initime = datatime
1241 else:
1242 else:
1242 self.__initime += deltatime
1243 self.__initime += deltatime
1243
1244
1244 return avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc
1245 return avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc
1245
1246
1246 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
1247 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
1247
1248
1248 if not self.__isConfig:
1249 if not self.__isConfig:
1249 self.setup(n, timeInterval, overlapping)
1250 self.setup(n, timeInterval, overlapping)
1250 self.__isConfig = True
1251 self.__isConfig = True
1251
1252
1252 avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
1253 avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
1253 dataOut.data_spc,
1254 dataOut.data_spc,
1254 dataOut.data_cspc,
1255 dataOut.data_cspc,
1255 dataOut.data_dc)
1256 dataOut.data_dc)
1256
1257
1257 # dataOut.timeInterval *= n
1258 # dataOut.timeInterval *= n
1258 dataOut.flagNoData = True
1259 dataOut.flagNoData = True
1259
1260
1260 if self.__dataReady:
1261 if self.__dataReady:
1261
1262
1262 dataOut.data_spc = avgdata_spc
1263 dataOut.data_spc = avgdata_spc
1263 dataOut.data_cspc = avgdata_cspc
1264 dataOut.data_cspc = avgdata_cspc
1264 dataOut.data_dc = avgdata_dc
1265 dataOut.data_dc = avgdata_dc
1265
1266
1266 dataOut.nIncohInt *= self.n
1267 dataOut.nIncohInt *= self.n
1267 dataOut.utctime = avgdatatime
1268 dataOut.utctime = avgdatatime
1268 #dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints
1269 #dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints
1269 dataOut.timeInterval = self.__timeInterval*self.n
1270 dataOut.timeInterval = self.__timeInterval*self.n
1270 dataOut.flagNoData = False
1271 dataOut.flagNoData = False
1271
1272
1272 class ProfileSelector(Operation):
1273 class ProfileSelector(Operation):
1273
1274
1274 profileIndex = None
1275 profileIndex = None
1275 # Tamanho total de los perfiles
1276 # Tamanho total de los perfiles
1276 nProfiles = None
1277 nProfiles = None
1277
1278
1278 def __init__(self):
1279 def __init__(self):
1279
1280
1280 self.profileIndex = 0
1281 self.profileIndex = 0
1281
1282
1282 def incIndex(self):
1283 def incIndex(self):
1283 self.profileIndex += 1
1284 self.profileIndex += 1
1284
1285
1285 if self.profileIndex >= self.nProfiles:
1286 if self.profileIndex >= self.nProfiles:
1286 self.profileIndex = 0
1287 self.profileIndex = 0
1287
1288
1288 def isProfileInRange(self, minIndex, maxIndex):
1289 def isProfileInRange(self, minIndex, maxIndex):
1289
1290
1290 if self.profileIndex < minIndex:
1291 if self.profileIndex < minIndex:
1291 return False
1292 return False
1292
1293
1293 if self.profileIndex > maxIndex:
1294 if self.profileIndex > maxIndex:
1294 return False
1295 return False
1295
1296
1296 return True
1297 return True
1297
1298
1298 def isProfileInList(self, profileList):
1299 def isProfileInList(self, profileList):
1299
1300
1300 if self.profileIndex not in profileList:
1301 if self.profileIndex not in profileList:
1301 return False
1302 return False
1302
1303
1303 return True
1304 return True
1304
1305
1305 def run(self, dataOut, profileList=None, profileRangeList=None):
1306 def run(self, dataOut, profileList=None, profileRangeList=None):
1306
1307
1307 dataOut.flagNoData = True
1308 dataOut.flagNoData = True
1308 self.nProfiles = dataOut.nProfiles
1309 self.nProfiles = dataOut.nProfiles
1309
1310
1310 if profileList != None:
1311 if profileList != None:
1311 if self.isProfileInList(profileList):
1312 if self.isProfileInList(profileList):
1312 dataOut.flagNoData = False
1313 dataOut.flagNoData = False
1313
1314
1314 self.incIndex()
1315 self.incIndex()
1315 return 1
1316 return 1
1316
1317
1317
1318
1318 elif profileRangeList != None:
1319 elif profileRangeList != None:
1319 minIndex = profileRangeList[0]
1320 minIndex = profileRangeList[0]
1320 maxIndex = profileRangeList[1]
1321 maxIndex = profileRangeList[1]
1321 if self.isProfileInRange(minIndex, maxIndex):
1322 if self.isProfileInRange(minIndex, maxIndex):
1322 dataOut.flagNoData = False
1323 dataOut.flagNoData = False
1323
1324
1324 self.incIndex()
1325 self.incIndex()
1325 return 1
1326 return 1
1326
1327
1327 else:
1328 else:
1328 raise ValueError, "ProfileSelector needs profileList or profileRangeList"
1329 raise ValueError, "ProfileSelector needs profileList or profileRangeList"
1329
1330
1330 return 0
1331 return 0
1331
1332
General Comments 0
You need to be logged in to leave comments. Login now