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