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