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