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