##// END OF EJS Templates
schain
RSS
Actualiza la variable "realtime" del objeto dataOut, de Voltage a Spectra
Daniel Valdez -
r408:547afa1143b4
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1655 +1,1656
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=None, maxHei=None):
276 def selectHeights(self, minHei=None, maxHei=None):
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
291
292 if minHei == None:
292 if minHei == None:
293 minHei = self.dataOut.heightList[0]
293 minHei = self.dataOut.heightList[0]
294
294
295 if maxHei == None:
295 if maxHei == None:
296 maxHei = self.dataOut.heightList[-1]
296 maxHei = self.dataOut.heightList[-1]
297
297
298 if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
298 if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
299 raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
299 raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
300
300
301
301
302 if (maxHei > self.dataOut.heightList[-1]):
302 if (maxHei > self.dataOut.heightList[-1]):
303 maxHei = self.dataOut.heightList[-1]
303 maxHei = self.dataOut.heightList[-1]
304 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
304 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
305
305
306 minIndex = 0
306 minIndex = 0
307 maxIndex = 0
307 maxIndex = 0
308 heights = self.dataOut.heightList
308 heights = self.dataOut.heightList
309
309
310 inda = numpy.where(heights >= minHei)
310 inda = numpy.where(heights >= minHei)
311 indb = numpy.where(heights <= maxHei)
311 indb = numpy.where(heights <= maxHei)
312
312
313 try:
313 try:
314 minIndex = inda[0][0]
314 minIndex = inda[0][0]
315 except:
315 except:
316 minIndex = 0
316 minIndex = 0
317
317
318 try:
318 try:
319 maxIndex = indb[0][-1]
319 maxIndex = indb[0][-1]
320 except:
320 except:
321 maxIndex = len(heights)
321 maxIndex = len(heights)
322
322
323 self.selectHeightsByIndex(minIndex, maxIndex)
323 self.selectHeightsByIndex(minIndex, maxIndex)
324
324
325 return 1
325 return 1
326
326
327
327
328 def selectHeightsByIndex(self, minIndex, maxIndex):
328 def selectHeightsByIndex(self, minIndex, maxIndex):
329 """
329 """
330 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
330 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
331 minIndex <= index <= maxIndex
331 minIndex <= index <= maxIndex
332
332
333 Input:
333 Input:
334 minIndex : valor de indice minimo de altura a considerar
334 minIndex : valor de indice minimo de altura a considerar
335 maxIndex : valor de indice maximo de altura a considerar
335 maxIndex : valor de indice maximo de altura a considerar
336
336
337 Affected:
337 Affected:
338 self.dataOut.data
338 self.dataOut.data
339 self.dataOut.heightList
339 self.dataOut.heightList
340
340
341 Return:
341 Return:
342 1 si el metodo se ejecuto con exito caso contrario devuelve 0
342 1 si el metodo se ejecuto con exito caso contrario devuelve 0
343 """
343 """
344
344
345 if (minIndex < 0) or (minIndex > maxIndex):
345 if (minIndex < 0) or (minIndex > maxIndex):
346 raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
346 raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
347
347
348 if (maxIndex >= self.dataOut.nHeights):
348 if (maxIndex >= self.dataOut.nHeights):
349 maxIndex = self.dataOut.nHeights-1
349 maxIndex = self.dataOut.nHeights-1
350 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
350 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
351
351
352 nHeights = maxIndex - minIndex + 1
352 nHeights = maxIndex - minIndex + 1
353
353
354 #voltage
354 #voltage
355 data = self.dataOut.data[:,minIndex:maxIndex+1]
355 data = self.dataOut.data[:,minIndex:maxIndex+1]
356
356
357 firstHeight = self.dataOut.heightList[minIndex]
357 firstHeight = self.dataOut.heightList[minIndex]
358
358
359 self.dataOut.data = data
359 self.dataOut.data = data
360 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
360 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
361
361
362 return 1
362 return 1
363
363
364
364
365 def filterByHeights(self, window):
365 def filterByHeights(self, window):
366 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
366 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
367
367
368 if window == None:
368 if window == None:
369 window = (self.dataOut.radarControllerHeaderObj.txA/self.dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
369 window = (self.dataOut.radarControllerHeaderObj.txA/self.dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
370
370
371 newdelta = deltaHeight * window
371 newdelta = deltaHeight * window
372 r = self.dataOut.data.shape[1] % window
372 r = self.dataOut.data.shape[1] % window
373 buffer = self.dataOut.data[:,0:self.dataOut.data.shape[1]-r]
373 buffer = self.dataOut.data[:,0:self.dataOut.data.shape[1]-r]
374 buffer = buffer.reshape(self.dataOut.data.shape[0],self.dataOut.data.shape[1]/window,window)
374 buffer = buffer.reshape(self.dataOut.data.shape[0],self.dataOut.data.shape[1]/window,window)
375 buffer = numpy.sum(buffer,2)
375 buffer = numpy.sum(buffer,2)
376 self.dataOut.data = buffer
376 self.dataOut.data = buffer
377 self.dataOut.heightList = numpy.arange(self.dataOut.heightList[0],newdelta*(self.dataOut.nHeights-r)/window,newdelta)
377 self.dataOut.heightList = numpy.arange(self.dataOut.heightList[0],newdelta*(self.dataOut.nHeights-r)/window,newdelta)
378 self.dataOut.windowOfFilter = window
378 self.dataOut.windowOfFilter = window
379
379
380 def deFlip(self):
380 def deFlip(self):
381 self.dataOut.data *= self.flip
381 self.dataOut.data *= self.flip
382 self.flip *= -1.
382 self.flip *= -1.
383
383
384 def setRadarFrequency(self, frequency=None):
384 def setRadarFrequency(self, frequency=None):
385 if frequency != None:
385 if frequency != None:
386 self.dataOut.frequency = frequency
386 self.dataOut.frequency = frequency
387
387
388 return 1
388 return 1
389
389
390 class CohInt(Operation):
390 class CohInt(Operation):
391
391
392 __isConfig = False
392 __isConfig = False
393
393
394 __profIndex = 0
394 __profIndex = 0
395 __withOverapping = False
395 __withOverapping = False
396
396
397 __byTime = False
397 __byTime = False
398 __initime = None
398 __initime = None
399 __lastdatatime = None
399 __lastdatatime = None
400 __integrationtime = None
400 __integrationtime = None
401
401
402 __buffer = None
402 __buffer = None
403
403
404 __dataReady = False
404 __dataReady = False
405
405
406 n = None
406 n = None
407
407
408
408
409 def __init__(self):
409 def __init__(self):
410
410
411 self.__isConfig = False
411 self.__isConfig = False
412
412
413 def setup(self, n=None, timeInterval=None, overlapping=False):
413 def setup(self, n=None, timeInterval=None, overlapping=False):
414 """
414 """
415 Set the parameters of the integration class.
415 Set the parameters of the integration class.
416
416
417 Inputs:
417 Inputs:
418
418
419 n : Number of coherent integrations
419 n : Number of coherent integrations
420 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
420 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
421 overlapping :
421 overlapping :
422
422
423 """
423 """
424
424
425 self.__initime = None
425 self.__initime = None
426 self.__lastdatatime = 0
426 self.__lastdatatime = 0
427 self.__buffer = None
427 self.__buffer = None
428 self.__dataReady = False
428 self.__dataReady = False
429
429
430
430
431 if n == None and timeInterval == None:
431 if n == None and timeInterval == None:
432 raise ValueError, "n or timeInterval should be specified ..."
432 raise ValueError, "n or timeInterval should be specified ..."
433
433
434 if n != None:
434 if n != None:
435 self.n = n
435 self.n = n
436 self.__byTime = False
436 self.__byTime = False
437 else:
437 else:
438 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
438 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
439 self.n = 9999
439 self.n = 9999
440 self.__byTime = True
440 self.__byTime = True
441
441
442 if overlapping:
442 if overlapping:
443 self.__withOverapping = True
443 self.__withOverapping = True
444 self.__buffer = None
444 self.__buffer = None
445 else:
445 else:
446 self.__withOverapping = False
446 self.__withOverapping = False
447 self.__buffer = 0
447 self.__buffer = 0
448
448
449 self.__profIndex = 0
449 self.__profIndex = 0
450
450
451 def putData(self, data):
451 def putData(self, data):
452
452
453 """
453 """
454 Add a profile to the __buffer and increase in one the __profileIndex
454 Add a profile to the __buffer and increase in one the __profileIndex
455
455
456 """
456 """
457
457
458 if not self.__withOverapping:
458 if not self.__withOverapping:
459 self.__buffer += data.copy()
459 self.__buffer += data.copy()
460 self.__profIndex += 1
460 self.__profIndex += 1
461 return
461 return
462
462
463 #Overlapping data
463 #Overlapping data
464 nChannels, nHeis = data.shape
464 nChannels, nHeis = data.shape
465 data = numpy.reshape(data, (1, nChannels, nHeis))
465 data = numpy.reshape(data, (1, nChannels, nHeis))
466
466
467 #If the buffer is empty then it takes the data value
467 #If the buffer is empty then it takes the data value
468 if self.__buffer == None:
468 if self.__buffer == None:
469 self.__buffer = data
469 self.__buffer = data
470 self.__profIndex += 1
470 self.__profIndex += 1
471 return
471 return
472
472
473 #If the buffer length is lower than n then stakcing the data value
473 #If the buffer length is lower than n then stakcing the data value
474 if self.__profIndex < self.n:
474 if self.__profIndex < self.n:
475 self.__buffer = numpy.vstack((self.__buffer, data))
475 self.__buffer = numpy.vstack((self.__buffer, data))
476 self.__profIndex += 1
476 self.__profIndex += 1
477 return
477 return
478
478
479 #If the buffer length is equal to n then replacing the last buffer value with the data value
479 #If the buffer length is equal to n then replacing the last buffer value with the data value
480 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
480 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
481 self.__buffer[self.n-1] = data
481 self.__buffer[self.n-1] = data
482 self.__profIndex = self.n
482 self.__profIndex = self.n
483 return
483 return
484
484
485
485
486 def pushData(self):
486 def pushData(self):
487 """
487 """
488 Return the sum of the last profiles and the profiles used in the sum.
488 Return the sum of the last profiles and the profiles used in the sum.
489
489
490 Affected:
490 Affected:
491
491
492 self.__profileIndex
492 self.__profileIndex
493
493
494 """
494 """
495
495
496 if not self.__withOverapping:
496 if not self.__withOverapping:
497 data = self.__buffer
497 data = self.__buffer
498 n = self.__profIndex
498 n = self.__profIndex
499
499
500 self.__buffer = 0
500 self.__buffer = 0
501 self.__profIndex = 0
501 self.__profIndex = 0
502
502
503 return data, n
503 return data, n
504
504
505 #Integration with Overlapping
505 #Integration with Overlapping
506 data = numpy.sum(self.__buffer, axis=0)
506 data = numpy.sum(self.__buffer, axis=0)
507 n = self.__profIndex
507 n = self.__profIndex
508
508
509 return data, n
509 return data, n
510
510
511 def byProfiles(self, data):
511 def byProfiles(self, data):
512
512
513 self.__dataReady = False
513 self.__dataReady = False
514 avgdata = None
514 avgdata = None
515 n = None
515 n = None
516
516
517 self.putData(data)
517 self.putData(data)
518
518
519 if self.__profIndex == self.n:
519 if self.__profIndex == self.n:
520
520
521 avgdata, n = self.pushData()
521 avgdata, n = self.pushData()
522 self.__dataReady = True
522 self.__dataReady = True
523
523
524 return avgdata
524 return avgdata
525
525
526 def byTime(self, data, datatime):
526 def byTime(self, data, datatime):
527
527
528 self.__dataReady = False
528 self.__dataReady = False
529 avgdata = None
529 avgdata = None
530 n = None
530 n = None
531
531
532 self.putData(data)
532 self.putData(data)
533
533
534 if (datatime - self.__initime) >= self.__integrationtime:
534 if (datatime - self.__initime) >= self.__integrationtime:
535 avgdata, n = self.pushData()
535 avgdata, n = self.pushData()
536 self.n = n
536 self.n = n
537 self.__dataReady = True
537 self.__dataReady = True
538
538
539 return avgdata
539 return avgdata
540
540
541 def integrate(self, data, datatime=None):
541 def integrate(self, data, datatime=None):
542
542
543 if self.__initime == None:
543 if self.__initime == None:
544 self.__initime = datatime
544 self.__initime = datatime
545
545
546 if self.__byTime:
546 if self.__byTime:
547 avgdata = self.byTime(data, datatime)
547 avgdata = self.byTime(data, datatime)
548 else:
548 else:
549 avgdata = self.byProfiles(data)
549 avgdata = self.byProfiles(data)
550
550
551
551
552 self.__lastdatatime = datatime
552 self.__lastdatatime = datatime
553
553
554 if avgdata == None:
554 if avgdata == None:
555 return None, None
555 return None, None
556
556
557 avgdatatime = self.__initime
557 avgdatatime = self.__initime
558
558
559 deltatime = datatime -self.__lastdatatime
559 deltatime = datatime -self.__lastdatatime
560
560
561 if not self.__withOverapping:
561 if not self.__withOverapping:
562 self.__initime = datatime
562 self.__initime = datatime
563 else:
563 else:
564 self.__initime += deltatime
564 self.__initime += deltatime
565
565
566 return avgdata, avgdatatime
566 return avgdata, avgdatatime
567
567
568 def run(self, dataOut, **kwargs):
568 def run(self, dataOut, **kwargs):
569
569
570 if not self.__isConfig:
570 if not self.__isConfig:
571 self.setup(**kwargs)
571 self.setup(**kwargs)
572 self.__isConfig = True
572 self.__isConfig = True
573
573
574 avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
574 avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
575
575
576 # dataOut.timeInterval *= n
576 # dataOut.timeInterval *= n
577 dataOut.flagNoData = True
577 dataOut.flagNoData = True
578
578
579 if self.__dataReady:
579 if self.__dataReady:
580 dataOut.data = avgdata
580 dataOut.data = avgdata
581 dataOut.nCohInt *= self.n
581 dataOut.nCohInt *= self.n
582 dataOut.utctime = avgdatatime
582 dataOut.utctime = avgdatatime
583 dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
583 dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
584 dataOut.flagNoData = False
584 dataOut.flagNoData = False
585
585
586
586
587 class Decoder(Operation):
587 class Decoder(Operation):
588
588
589 __isConfig = False
589 __isConfig = False
590 __profIndex = 0
590 __profIndex = 0
591
591
592 code = None
592 code = None
593
593
594 nCode = None
594 nCode = None
595 nBaud = None
595 nBaud = None
596
596
597 def __init__(self):
597 def __init__(self):
598
598
599 self.__isConfig = False
599 self.__isConfig = False
600
600
601 def setup(self, code, shape):
601 def setup(self, code, shape):
602
602
603 self.__profIndex = 0
603 self.__profIndex = 0
604
604
605 self.code = code
605 self.code = code
606
606
607 self.nCode = len(code)
607 self.nCode = len(code)
608 self.nBaud = len(code[0])
608 self.nBaud = len(code[0])
609
609
610 self.__nChannels, self.__nHeis = shape
610 self.__nChannels, self.__nHeis = shape
611
611
612 __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
612 __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
613
613
614 __codeBuffer[:,0:self.nBaud] = self.code
614 __codeBuffer[:,0:self.nBaud] = self.code
615
615
616 self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
616 self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
617
617
618 self.ndatadec = self.__nHeis - self.nBaud + 1
618 self.ndatadec = self.__nHeis - self.nBaud + 1
619
619
620 self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
620 self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
621
621
622 def convolutionInFreq(self, data):
622 def convolutionInFreq(self, data):
623
623
624 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
624 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
625
625
626 fft_data = numpy.fft.fft(data, axis=1)
626 fft_data = numpy.fft.fft(data, axis=1)
627
627
628 conv = fft_data*fft_code
628 conv = fft_data*fft_code
629
629
630 data = numpy.fft.ifft(conv,axis=1)
630 data = numpy.fft.ifft(conv,axis=1)
631
631
632 datadec = data[:,:-self.nBaud+1]
632 datadec = data[:,:-self.nBaud+1]
633
633
634 return datadec
634 return datadec
635
635
636 def convolutionInFreqOpt(self, data):
636 def convolutionInFreqOpt(self, data):
637
637
638 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
638 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
639
639
640 data = cfunctions.decoder(fft_code, data)
640 data = cfunctions.decoder(fft_code, data)
641
641
642 datadec = data[:,:-self.nBaud+1]
642 datadec = data[:,:-self.nBaud+1]
643
643
644 return datadec
644 return datadec
645
645
646 def convolutionInTime(self, data):
646 def convolutionInTime(self, data):
647
647
648 code = self.code[self.__profIndex]
648 code = self.code[self.__profIndex]
649
649
650 for i in range(self.__nChannels):
650 for i in range(self.__nChannels):
651 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='valid')
651 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='valid')
652
652
653 return self.datadecTime
653 return self.datadecTime
654
654
655 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0):
655 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0):
656
656
657 if not self.__isConfig:
657 if not self.__isConfig:
658
658
659 if code == None:
659 if code == None:
660 code = dataOut.code
660 code = dataOut.code
661 else:
661 else:
662 code = numpy.array(code).reshape(nCode,nBaud)
662 code = numpy.array(code).reshape(nCode,nBaud)
663 dataOut.code = code
663 dataOut.code = code
664 dataOut.nCode = nCode
664 dataOut.nCode = nCode
665 dataOut.nBaud = nBaud
665 dataOut.nBaud = nBaud
666
666
667 if code == None:
667 if code == None:
668 return 1
668 return 1
669
669
670 self.setup(code, dataOut.data.shape)
670 self.setup(code, dataOut.data.shape)
671 self.__isConfig = True
671 self.__isConfig = True
672
672
673 if mode == 0:
673 if mode == 0:
674 datadec = self.convolutionInTime(dataOut.data)
674 datadec = self.convolutionInTime(dataOut.data)
675
675
676 if mode == 1:
676 if mode == 1:
677 datadec = self.convolutionInFreq(dataOut.data)
677 datadec = self.convolutionInFreq(dataOut.data)
678
678
679 if mode == 2:
679 if mode == 2:
680 datadec = self.convolutionInFreqOpt(dataOut.data)
680 datadec = self.convolutionInFreqOpt(dataOut.data)
681
681
682 dataOut.data = datadec
682 dataOut.data = datadec
683
683
684 dataOut.heightList = dataOut.heightList[0:self.ndatadec]
684 dataOut.heightList = dataOut.heightList[0:self.ndatadec]
685
685
686 dataOut.flagDecodeData = True #asumo q la data no esta decodificada
686 dataOut.flagDecodeData = True #asumo q la data no esta decodificada
687
687
688 if self.__profIndex == self.nCode-1:
688 if self.__profIndex == self.nCode-1:
689 self.__profIndex = 0
689 self.__profIndex = 0
690 return 1
690 return 1
691
691
692 self.__profIndex += 1
692 self.__profIndex += 1
693
693
694 return 1
694 return 1
695 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
695 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
696
696
697
697
698
698
699 class SpectraProc(ProcessingUnit):
699 class SpectraProc(ProcessingUnit):
700
700
701 def __init__(self):
701 def __init__(self):
702
702
703 self.objectDict = {}
703 self.objectDict = {}
704 self.buffer = None
704 self.buffer = None
705 self.firstdatatime = None
705 self.firstdatatime = None
706 self.profIndex = 0
706 self.profIndex = 0
707 self.dataOut = Spectra()
707 self.dataOut = Spectra()
708
708
709 def __updateObjFromInput(self):
709 def __updateObjFromInput(self):
710
710
711 self.dataOut.timeZone = self.dataIn.timeZone
711 self.dataOut.timeZone = self.dataIn.timeZone
712 self.dataOut.dstFlag = self.dataIn.dstFlag
712 self.dataOut.dstFlag = self.dataIn.dstFlag
713 self.dataOut.errorCount = self.dataIn.errorCount
713 self.dataOut.errorCount = self.dataIn.errorCount
714 self.dataOut.useLocalTime = self.dataIn.useLocalTime
714 self.dataOut.useLocalTime = self.dataIn.useLocalTime
715
715
716 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
716 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
717 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
717 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
718 self.dataOut.channelList = self.dataIn.channelList
718 self.dataOut.channelList = self.dataIn.channelList
719 self.dataOut.heightList = self.dataIn.heightList
719 self.dataOut.heightList = self.dataIn.heightList
720 self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
720 self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
721 # self.dataOut.nHeights = self.dataIn.nHeights
721 # self.dataOut.nHeights = self.dataIn.nHeights
722 # self.dataOut.nChannels = self.dataIn.nChannels
722 # self.dataOut.nChannels = self.dataIn.nChannels
723 self.dataOut.nBaud = self.dataIn.nBaud
723 self.dataOut.nBaud = self.dataIn.nBaud
724 self.dataOut.nCode = self.dataIn.nCode
724 self.dataOut.nCode = self.dataIn.nCode
725 self.dataOut.code = self.dataIn.code
725 self.dataOut.code = self.dataIn.code
726 self.dataOut.nProfiles = self.dataOut.nFFTPoints
726 self.dataOut.nProfiles = self.dataOut.nFFTPoints
727 # self.dataOut.channelIndexList = self.dataIn.channelIndexList
727 # self.dataOut.channelIndexList = self.dataIn.channelIndexList
728 self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
728 self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
729 self.dataOut.utctime = self.firstdatatime
729 self.dataOut.utctime = self.firstdatatime
730 self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
730 self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
731 self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
731 self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
732 # self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
732 # self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
733 self.dataOut.nCohInt = self.dataIn.nCohInt
733 self.dataOut.nCohInt = self.dataIn.nCohInt
734 self.dataOut.nIncohInt = 1
734 self.dataOut.nIncohInt = 1
735 self.dataOut.ippSeconds = self.dataIn.ippSeconds
735 self.dataOut.ippSeconds = self.dataIn.ippSeconds
736 self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
736 self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
737
737
738 self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
738 self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
739 self.dataOut.frequency = self.dataIn.frequency
739 self.dataOut.frequency = self.dataIn.frequency
740 self.dataOut.realtime = self.dataIn.realtime
740
741
741 def __getFft(self):
742 def __getFft(self):
742 """
743 """
743 Convierte valores de Voltaje a Spectra
744 Convierte valores de Voltaje a Spectra
744
745
745 Affected:
746 Affected:
746 self.dataOut.data_spc
747 self.dataOut.data_spc
747 self.dataOut.data_cspc
748 self.dataOut.data_cspc
748 self.dataOut.data_dc
749 self.dataOut.data_dc
749 self.dataOut.heightList
750 self.dataOut.heightList
750 self.profIndex
751 self.profIndex
751 self.buffer
752 self.buffer
752 self.dataOut.flagNoData
753 self.dataOut.flagNoData
753 """
754 """
754 fft_volt = numpy.fft.fft(self.buffer,n=self.dataOut.nFFTPoints,axis=1)
755 fft_volt = numpy.fft.fft(self.buffer,n=self.dataOut.nFFTPoints,axis=1)
755 fft_volt = fft_volt.astype(numpy.dtype('complex'))
756 fft_volt = fft_volt.astype(numpy.dtype('complex'))
756 dc = fft_volt[:,0,:]
757 dc = fft_volt[:,0,:]
757
758
758 #calculo de self-spectra
759 #calculo de self-spectra
759 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
760 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
760 spc = fft_volt * numpy.conjugate(fft_volt)
761 spc = fft_volt * numpy.conjugate(fft_volt)
761 spc = spc.real
762 spc = spc.real
762
763
763 blocksize = 0
764 blocksize = 0
764 blocksize += dc.size
765 blocksize += dc.size
765 blocksize += spc.size
766 blocksize += spc.size
766
767
767 cspc = None
768 cspc = None
768 pairIndex = 0
769 pairIndex = 0
769 if self.dataOut.pairsList != None:
770 if self.dataOut.pairsList != None:
770 #calculo de cross-spectra
771 #calculo de cross-spectra
771 cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
772 cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
772 for pair in self.dataOut.pairsList:
773 for pair in self.dataOut.pairsList:
773 cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
774 cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
774 pairIndex += 1
775 pairIndex += 1
775 blocksize += cspc.size
776 blocksize += cspc.size
776
777
777 self.dataOut.data_spc = spc
778 self.dataOut.data_spc = spc
778 self.dataOut.data_cspc = cspc
779 self.dataOut.data_cspc = cspc
779 self.dataOut.data_dc = dc
780 self.dataOut.data_dc = dc
780 self.dataOut.blockSize = blocksize
781 self.dataOut.blockSize = blocksize
781 self.dataOut.flagShiftFFT = False
782 self.dataOut.flagShiftFFT = False
782
783
783 def init(self, nProfiles, nFFTPoints=None, pairsList=None):
784 def init(self, nProfiles, nFFTPoints=None, pairsList=None):
784
785
785 self.dataOut.flagNoData = True
786 self.dataOut.flagNoData = True
786
787
787 if self.dataIn.type == "Spectra":
788 if self.dataIn.type == "Spectra":
788 self.dataOut.copy(self.dataIn)
789 self.dataOut.copy(self.dataIn)
789 return
790 return
790
791
791 if self.dataIn.type == "Voltage":
792 if self.dataIn.type == "Voltage":
792
793
793 if nFFTPoints == None:
794 if nFFTPoints == None:
794 raise ValueError, "This SpectraProc.init() need nFFTPoints input variable"
795 raise ValueError, "This SpectraProc.init() need nFFTPoints input variable"
795
796
796 if pairsList == None:
797 if pairsList == None:
797 nPairs = 0
798 nPairs = 0
798 else:
799 else:
799 nPairs = len(pairsList)
800 nPairs = len(pairsList)
800
801
801 self.dataOut.nFFTPoints = nFFTPoints
802 self.dataOut.nFFTPoints = nFFTPoints
802 self.dataOut.pairsList = pairsList
803 self.dataOut.pairsList = pairsList
803 self.dataOut.nPairs = nPairs
804 self.dataOut.nPairs = nPairs
804
805
805 if self.buffer == None:
806 if self.buffer == None:
806 self.buffer = numpy.zeros((self.dataIn.nChannels,
807 self.buffer = numpy.zeros((self.dataIn.nChannels,
807 nProfiles,
808 nProfiles,
808 self.dataIn.nHeights),
809 self.dataIn.nHeights),
809 dtype='complex')
810 dtype='complex')
810
811
811
812
812 self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
813 self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
813 self.profIndex += 1
814 self.profIndex += 1
814
815
815 if self.firstdatatime == None:
816 if self.firstdatatime == None:
816 self.firstdatatime = self.dataIn.utctime
817 self.firstdatatime = self.dataIn.utctime
817
818
818 if self.profIndex == self.dataOut.nFFTPoints:
819 if self.profIndex == self.dataOut.nFFTPoints:
819 self.__updateObjFromInput()
820 self.__updateObjFromInput()
820 self.__getFft()
821 self.__getFft()
821
822
822 self.dataOut.flagNoData = False
823 self.dataOut.flagNoData = False
823
824
824 self.buffer = None
825 self.buffer = None
825 self.firstdatatime = None
826 self.firstdatatime = None
826 self.profIndex = 0
827 self.profIndex = 0
827
828
828 return
829 return
829
830
830 raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
831 raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
831
832
832 def selectChannels(self, channelList):
833 def selectChannels(self, channelList):
833
834
834 channelIndexList = []
835 channelIndexList = []
835
836
836 for channel in channelList:
837 for channel in channelList:
837 index = self.dataOut.channelList.index(channel)
838 index = self.dataOut.channelList.index(channel)
838 channelIndexList.append(index)
839 channelIndexList.append(index)
839
840
840 self.selectChannelsByIndex(channelIndexList)
841 self.selectChannelsByIndex(channelIndexList)
841
842
842 def selectChannelsByIndex(self, channelIndexList):
843 def selectChannelsByIndex(self, channelIndexList):
843 """
844 """
844 Selecciona un bloque de datos en base a canales segun el channelIndexList
845 Selecciona un bloque de datos en base a canales segun el channelIndexList
845
846
846 Input:
847 Input:
847 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
848 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
848
849
849 Affected:
850 Affected:
850 self.dataOut.data_spc
851 self.dataOut.data_spc
851 self.dataOut.channelIndexList
852 self.dataOut.channelIndexList
852 self.dataOut.nChannels
853 self.dataOut.nChannels
853
854
854 Return:
855 Return:
855 None
856 None
856 """
857 """
857
858
858 for channelIndex in channelIndexList:
859 for channelIndex in channelIndexList:
859 if channelIndex not in self.dataOut.channelIndexList:
860 if channelIndex not in self.dataOut.channelIndexList:
860 print channelIndexList
861 print channelIndexList
861 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
862 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
862
863
863 nChannels = len(channelIndexList)
864 nChannels = len(channelIndexList)
864
865
865 data_spc = self.dataOut.data_spc[channelIndexList,:]
866 data_spc = self.dataOut.data_spc[channelIndexList,:]
866
867
867 self.dataOut.data_spc = data_spc
868 self.dataOut.data_spc = data_spc
868 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
869 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
869 # self.dataOut.nChannels = nChannels
870 # self.dataOut.nChannels = nChannels
870
871
871 return 1
872 return 1
872
873
873 def selectHeights(self, minHei, maxHei):
874 def selectHeights(self, minHei, maxHei):
874 """
875 """
875 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
876 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
876 minHei <= height <= maxHei
877 minHei <= height <= maxHei
877
878
878 Input:
879 Input:
879 minHei : valor minimo de altura a considerar
880 minHei : valor minimo de altura a considerar
880 maxHei : valor maximo de altura a considerar
881 maxHei : valor maximo de altura a considerar
881
882
882 Affected:
883 Affected:
883 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
884 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
884
885
885 Return:
886 Return:
886 1 si el metodo se ejecuto con exito caso contrario devuelve 0
887 1 si el metodo se ejecuto con exito caso contrario devuelve 0
887 """
888 """
888 if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
889 if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
889 raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
890 raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
890
891
891 if (maxHei > self.dataOut.heightList[-1]):
892 if (maxHei > self.dataOut.heightList[-1]):
892 maxHei = self.dataOut.heightList[-1]
893 maxHei = self.dataOut.heightList[-1]
893 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
894 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
894
895
895 minIndex = 0
896 minIndex = 0
896 maxIndex = 0
897 maxIndex = 0
897 heights = self.dataOut.heightList
898 heights = self.dataOut.heightList
898
899
899 inda = numpy.where(heights >= minHei)
900 inda = numpy.where(heights >= minHei)
900 indb = numpy.where(heights <= maxHei)
901 indb = numpy.where(heights <= maxHei)
901
902
902 try:
903 try:
903 minIndex = inda[0][0]
904 minIndex = inda[0][0]
904 except:
905 except:
905 minIndex = 0
906 minIndex = 0
906
907
907 try:
908 try:
908 maxIndex = indb[0][-1]
909 maxIndex = indb[0][-1]
909 except:
910 except:
910 maxIndex = len(heights)
911 maxIndex = len(heights)
911
912
912 self.selectHeightsByIndex(minIndex, maxIndex)
913 self.selectHeightsByIndex(minIndex, maxIndex)
913
914
914 return 1
915 return 1
915
916
916
917
917 def selectHeightsByIndex(self, minIndex, maxIndex):
918 def selectHeightsByIndex(self, minIndex, maxIndex):
918 """
919 """
919 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
920 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
920 minIndex <= index <= maxIndex
921 minIndex <= index <= maxIndex
921
922
922 Input:
923 Input:
923 minIndex : valor de indice minimo de altura a considerar
924 minIndex : valor de indice minimo de altura a considerar
924 maxIndex : valor de indice maximo de altura a considerar
925 maxIndex : valor de indice maximo de altura a considerar
925
926
926 Affected:
927 Affected:
927 self.dataOut.data_spc
928 self.dataOut.data_spc
928 self.dataOut.data_cspc
929 self.dataOut.data_cspc
929 self.dataOut.data_dc
930 self.dataOut.data_dc
930 self.dataOut.heightList
931 self.dataOut.heightList
931
932
932 Return:
933 Return:
933 1 si el metodo se ejecuto con exito caso contrario devuelve 0
934 1 si el metodo se ejecuto con exito caso contrario devuelve 0
934 """
935 """
935
936
936 if (minIndex < 0) or (minIndex > maxIndex):
937 if (minIndex < 0) or (minIndex > maxIndex):
937 raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
938 raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
938
939
939 if (maxIndex >= self.dataOut.nHeights):
940 if (maxIndex >= self.dataOut.nHeights):
940 maxIndex = self.dataOut.nHeights-1
941 maxIndex = self.dataOut.nHeights-1
941 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
942 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
942
943
943 nHeights = maxIndex - minIndex + 1
944 nHeights = maxIndex - minIndex + 1
944
945
945 #Spectra
946 #Spectra
946 data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
947 data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
947
948
948 data_cspc = None
949 data_cspc = None
949 if self.dataOut.data_cspc != None:
950 if self.dataOut.data_cspc != None:
950 data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
951 data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
951
952
952 data_dc = None
953 data_dc = None
953 if self.dataOut.data_dc != None:
954 if self.dataOut.data_dc != None:
954 data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
955 data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
955
956
956 self.dataOut.data_spc = data_spc
957 self.dataOut.data_spc = data_spc
957 self.dataOut.data_cspc = data_cspc
958 self.dataOut.data_cspc = data_cspc
958 self.dataOut.data_dc = data_dc
959 self.dataOut.data_dc = data_dc
959
960
960 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
961 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
961
962
962 return 1
963 return 1
963
964
964 def removeDC(self, mode = 1):
965 def removeDC(self, mode = 1):
965
966
966 dc_index = 0
967 dc_index = 0
967 freq_index = numpy.array([-2,-1,1,2])
968 freq_index = numpy.array([-2,-1,1,2])
968 data_spc = self.dataOut.data_spc
969 data_spc = self.dataOut.data_spc
969 data_cspc = self.dataOut.data_cspc
970 data_cspc = self.dataOut.data_cspc
970 data_dc = self.dataOut.data_dc
971 data_dc = self.dataOut.data_dc
971
972
972 if self.dataOut.flagShiftFFT:
973 if self.dataOut.flagShiftFFT:
973 dc_index += self.dataOut.nFFTPoints/2
974 dc_index += self.dataOut.nFFTPoints/2
974 freq_index += self.dataOut.nFFTPoints/2
975 freq_index += self.dataOut.nFFTPoints/2
975
976
976 if mode == 1:
977 if mode == 1:
977 data_spc[dc_index] = (data_spc[:,freq_index[1],:] + data_spc[:,freq_index[2],:])/2
978 data_spc[dc_index] = (data_spc[:,freq_index[1],:] + data_spc[:,freq_index[2],:])/2
978 if data_cspc != None:
979 if data_cspc != None:
979 data_cspc[dc_index] = (data_cspc[:,freq_index[1],:] + data_cspc[:,freq_index[2],:])/2
980 data_cspc[dc_index] = (data_cspc[:,freq_index[1],:] + data_cspc[:,freq_index[2],:])/2
980 return 1
981 return 1
981
982
982 if mode == 2:
983 if mode == 2:
983 pass
984 pass
984
985
985 if mode == 3:
986 if mode == 3:
986 pass
987 pass
987
988
988 raise ValueError, "mode parameter has to be 1, 2 or 3"
989 raise ValueError, "mode parameter has to be 1, 2 or 3"
989
990
990 def removeInterference(self):
991 def removeInterference(self):
991
992
992 pass
993 pass
993
994
994 def setRadarFrequency(self, frequency=None):
995 def setRadarFrequency(self, frequency=None):
995 if frequency != None:
996 if frequency != None:
996 self.dataOut.frequency = frequency
997 self.dataOut.frequency = frequency
997
998
998 return 1
999 return 1
999
1000
1000
1001
1001 class IncohInt(Operation):
1002 class IncohInt(Operation):
1002
1003
1003
1004
1004 __profIndex = 0
1005 __profIndex = 0
1005 __withOverapping = False
1006 __withOverapping = False
1006
1007
1007 __byTime = False
1008 __byTime = False
1008 __initime = None
1009 __initime = None
1009 __lastdatatime = None
1010 __lastdatatime = None
1010 __integrationtime = None
1011 __integrationtime = None
1011
1012
1012 __buffer_spc = None
1013 __buffer_spc = None
1013 __buffer_cspc = None
1014 __buffer_cspc = None
1014 __buffer_dc = None
1015 __buffer_dc = None
1015
1016
1016 __dataReady = False
1017 __dataReady = False
1017
1018
1018 __timeInterval = None
1019 __timeInterval = None
1019
1020
1020 n = None
1021 n = None
1021
1022
1022
1023
1023
1024
1024 def __init__(self):
1025 def __init__(self):
1025
1026
1026 self.__isConfig = False
1027 self.__isConfig = False
1027
1028
1028 def setup(self, n=None, timeInterval=None, overlapping=False):
1029 def setup(self, n=None, timeInterval=None, overlapping=False):
1029 """
1030 """
1030 Set the parameters of the integration class.
1031 Set the parameters of the integration class.
1031
1032
1032 Inputs:
1033 Inputs:
1033
1034
1034 n : Number of coherent integrations
1035 n : Number of coherent integrations
1035 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
1036 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
1036 overlapping :
1037 overlapping :
1037
1038
1038 """
1039 """
1039
1040
1040 self.__initime = None
1041 self.__initime = None
1041 self.__lastdatatime = 0
1042 self.__lastdatatime = 0
1042 self.__buffer_spc = None
1043 self.__buffer_spc = None
1043 self.__buffer_cspc = None
1044 self.__buffer_cspc = None
1044 self.__buffer_dc = None
1045 self.__buffer_dc = None
1045 self.__dataReady = False
1046 self.__dataReady = False
1046
1047
1047
1048
1048 if n == None and timeInterval == None:
1049 if n == None and timeInterval == None:
1049 raise ValueError, "n or timeInterval should be specified ..."
1050 raise ValueError, "n or timeInterval should be specified ..."
1050
1051
1051 if n != None:
1052 if n != None:
1052 self.n = n
1053 self.n = n
1053 self.__byTime = False
1054 self.__byTime = False
1054 else:
1055 else:
1055 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
1056 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
1056 self.n = 9999
1057 self.n = 9999
1057 self.__byTime = True
1058 self.__byTime = True
1058
1059
1059 if overlapping:
1060 if overlapping:
1060 self.__withOverapping = True
1061 self.__withOverapping = True
1061 else:
1062 else:
1062 self.__withOverapping = False
1063 self.__withOverapping = False
1063 self.__buffer_spc = 0
1064 self.__buffer_spc = 0
1064 self.__buffer_cspc = 0
1065 self.__buffer_cspc = 0
1065 self.__buffer_dc = 0
1066 self.__buffer_dc = 0
1066
1067
1067 self.__profIndex = 0
1068 self.__profIndex = 0
1068
1069
1069 def putData(self, data_spc, data_cspc, data_dc):
1070 def putData(self, data_spc, data_cspc, data_dc):
1070
1071
1071 """
1072 """
1072 Add a profile to the __buffer_spc and increase in one the __profileIndex
1073 Add a profile to the __buffer_spc and increase in one the __profileIndex
1073
1074
1074 """
1075 """
1075
1076
1076 if not self.__withOverapping:
1077 if not self.__withOverapping:
1077 self.__buffer_spc += data_spc
1078 self.__buffer_spc += data_spc
1078
1079
1079 if data_cspc == None:
1080 if data_cspc == None:
1080 self.__buffer_cspc = None
1081 self.__buffer_cspc = None
1081 else:
1082 else:
1082 self.__buffer_cspc += data_cspc
1083 self.__buffer_cspc += data_cspc
1083
1084
1084 if data_dc == None:
1085 if data_dc == None:
1085 self.__buffer_dc = None
1086 self.__buffer_dc = None
1086 else:
1087 else:
1087 self.__buffer_dc += data_dc
1088 self.__buffer_dc += data_dc
1088
1089
1089 self.__profIndex += 1
1090 self.__profIndex += 1
1090 return
1091 return
1091
1092
1092 #Overlapping data
1093 #Overlapping data
1093 nChannels, nFFTPoints, nHeis = data_spc.shape
1094 nChannels, nFFTPoints, nHeis = data_spc.shape
1094 data_spc = numpy.reshape(data_spc, (1, nChannels, nFFTPoints, nHeis))
1095 data_spc = numpy.reshape(data_spc, (1, nChannels, nFFTPoints, nHeis))
1095 if data_cspc != None:
1096 if data_cspc != None:
1096 data_cspc = numpy.reshape(data_cspc, (1, -1, nFFTPoints, nHeis))
1097 data_cspc = numpy.reshape(data_cspc, (1, -1, nFFTPoints, nHeis))
1097 if data_dc != None:
1098 if data_dc != None:
1098 data_dc = numpy.reshape(data_dc, (1, -1, nHeis))
1099 data_dc = numpy.reshape(data_dc, (1, -1, nHeis))
1099
1100
1100 #If the buffer is empty then it takes the data value
1101 #If the buffer is empty then it takes the data value
1101 if self.__buffer_spc == None:
1102 if self.__buffer_spc == None:
1102 self.__buffer_spc = data_spc
1103 self.__buffer_spc = data_spc
1103
1104
1104 if data_cspc == None:
1105 if data_cspc == None:
1105 self.__buffer_cspc = None
1106 self.__buffer_cspc = None
1106 else:
1107 else:
1107 self.__buffer_cspc += data_cspc
1108 self.__buffer_cspc += data_cspc
1108
1109
1109 if data_dc == None:
1110 if data_dc == None:
1110 self.__buffer_dc = None
1111 self.__buffer_dc = None
1111 else:
1112 else:
1112 self.__buffer_dc += data_dc
1113 self.__buffer_dc += data_dc
1113
1114
1114 self.__profIndex += 1
1115 self.__profIndex += 1
1115 return
1116 return
1116
1117
1117 #If the buffer length is lower than n then stakcing the data value
1118 #If the buffer length is lower than n then stakcing the data value
1118 if self.__profIndex < self.n:
1119 if self.__profIndex < self.n:
1119 self.__buffer_spc = numpy.vstack((self.__buffer_spc, data_spc))
1120 self.__buffer_spc = numpy.vstack((self.__buffer_spc, data_spc))
1120
1121
1121 if data_cspc != None:
1122 if data_cspc != None:
1122 self.__buffer_cspc = numpy.vstack((self.__buffer_cspc, data_cspc))
1123 self.__buffer_cspc = numpy.vstack((self.__buffer_cspc, data_cspc))
1123
1124
1124 if data_dc != None:
1125 if data_dc != None:
1125 self.__buffer_dc = numpy.vstack((self.__buffer_dc, data_dc))
1126 self.__buffer_dc = numpy.vstack((self.__buffer_dc, data_dc))
1126
1127
1127 self.__profIndex += 1
1128 self.__profIndex += 1
1128 return
1129 return
1129
1130
1130 #If the buffer length is equal to n then replacing the last buffer value with the data value
1131 #If the buffer length is equal to n then replacing the last buffer value with the data value
1131 self.__buffer_spc = numpy.roll(self.__buffer_spc, -1, axis=0)
1132 self.__buffer_spc = numpy.roll(self.__buffer_spc, -1, axis=0)
1132 self.__buffer_spc[self.n-1] = data_spc
1133 self.__buffer_spc[self.n-1] = data_spc
1133
1134
1134 if data_cspc != None:
1135 if data_cspc != None:
1135 self.__buffer_cspc = numpy.roll(self.__buffer_cspc, -1, axis=0)
1136 self.__buffer_cspc = numpy.roll(self.__buffer_cspc, -1, axis=0)
1136 self.__buffer_cspc[self.n-1] = data_cspc
1137 self.__buffer_cspc[self.n-1] = data_cspc
1137
1138
1138 if data_dc != None:
1139 if data_dc != None:
1139 self.__buffer_dc = numpy.roll(self.__buffer_dc, -1, axis=0)
1140 self.__buffer_dc = numpy.roll(self.__buffer_dc, -1, axis=0)
1140 self.__buffer_dc[self.n-1] = data_dc
1141 self.__buffer_dc[self.n-1] = data_dc
1141
1142
1142 self.__profIndex = self.n
1143 self.__profIndex = self.n
1143 return
1144 return
1144
1145
1145
1146
1146 def pushData(self):
1147 def pushData(self):
1147 """
1148 """
1148 Return the sum of the last profiles and the profiles used in the sum.
1149 Return the sum of the last profiles and the profiles used in the sum.
1149
1150
1150 Affected:
1151 Affected:
1151
1152
1152 self.__profileIndex
1153 self.__profileIndex
1153
1154
1154 """
1155 """
1155 data_spc = None
1156 data_spc = None
1156 data_cspc = None
1157 data_cspc = None
1157 data_dc = None
1158 data_dc = None
1158
1159
1159 if not self.__withOverapping:
1160 if not self.__withOverapping:
1160 data_spc = self.__buffer_spc
1161 data_spc = self.__buffer_spc
1161 data_cspc = self.__buffer_cspc
1162 data_cspc = self.__buffer_cspc
1162 data_dc = self.__buffer_dc
1163 data_dc = self.__buffer_dc
1163
1164
1164 n = self.__profIndex
1165 n = self.__profIndex
1165
1166
1166 self.__buffer_spc = 0
1167 self.__buffer_spc = 0
1167 self.__buffer_cspc = 0
1168 self.__buffer_cspc = 0
1168 self.__buffer_dc = 0
1169 self.__buffer_dc = 0
1169 self.__profIndex = 0
1170 self.__profIndex = 0
1170
1171
1171 return data_spc, data_cspc, data_dc, n
1172 return data_spc, data_cspc, data_dc, n
1172
1173
1173 #Integration with Overlapping
1174 #Integration with Overlapping
1174 data_spc = numpy.sum(self.__buffer_spc, axis=0)
1175 data_spc = numpy.sum(self.__buffer_spc, axis=0)
1175
1176
1176 if self.__buffer_cspc != None:
1177 if self.__buffer_cspc != None:
1177 data_cspc = numpy.sum(self.__buffer_cspc, axis=0)
1178 data_cspc = numpy.sum(self.__buffer_cspc, axis=0)
1178
1179
1179 if self.__buffer_dc != None:
1180 if self.__buffer_dc != None:
1180 data_dc = numpy.sum(self.__buffer_dc, axis=0)
1181 data_dc = numpy.sum(self.__buffer_dc, axis=0)
1181
1182
1182 n = self.__profIndex
1183 n = self.__profIndex
1183
1184
1184 return data_spc, data_cspc, data_dc, n
1185 return data_spc, data_cspc, data_dc, n
1185
1186
1186 def byProfiles(self, *args):
1187 def byProfiles(self, *args):
1187
1188
1188 self.__dataReady = False
1189 self.__dataReady = False
1189 avgdata_spc = None
1190 avgdata_spc = None
1190 avgdata_cspc = None
1191 avgdata_cspc = None
1191 avgdata_dc = None
1192 avgdata_dc = None
1192 n = None
1193 n = None
1193
1194
1194 self.putData(*args)
1195 self.putData(*args)
1195
1196
1196 if self.__profIndex == self.n:
1197 if self.__profIndex == self.n:
1197
1198
1198 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1199 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1199 self.__dataReady = True
1200 self.__dataReady = True
1200
1201
1201 return avgdata_spc, avgdata_cspc, avgdata_dc
1202 return avgdata_spc, avgdata_cspc, avgdata_dc
1202
1203
1203 def byTime(self, datatime, *args):
1204 def byTime(self, datatime, *args):
1204
1205
1205 self.__dataReady = False
1206 self.__dataReady = False
1206 avgdata_spc = None
1207 avgdata_spc = None
1207 avgdata_cspc = None
1208 avgdata_cspc = None
1208 avgdata_dc = None
1209 avgdata_dc = None
1209 n = None
1210 n = None
1210
1211
1211 self.putData(*args)
1212 self.putData(*args)
1212
1213
1213 if (datatime - self.__initime) >= self.__integrationtime:
1214 if (datatime - self.__initime) >= self.__integrationtime:
1214 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1215 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
1215 self.n = n
1216 self.n = n
1216 self.__dataReady = True
1217 self.__dataReady = True
1217
1218
1218 return avgdata_spc, avgdata_cspc, avgdata_dc
1219 return avgdata_spc, avgdata_cspc, avgdata_dc
1219
1220
1220 def integrate(self, datatime, *args):
1221 def integrate(self, datatime, *args):
1221
1222
1222 if self.__initime == None:
1223 if self.__initime == None:
1223 self.__initime = datatime
1224 self.__initime = datatime
1224
1225
1225 if self.__byTime:
1226 if self.__byTime:
1226 avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
1227 avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
1227 else:
1228 else:
1228 avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
1229 avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
1229
1230
1230 self.__lastdatatime = datatime
1231 self.__lastdatatime = datatime
1231
1232
1232 if avgdata_spc == None:
1233 if avgdata_spc == None:
1233 return None, None, None, None
1234 return None, None, None, None
1234
1235
1235 avgdatatime = self.__initime
1236 avgdatatime = self.__initime
1236 try:
1237 try:
1237 self.__timeInterval = (self.__lastdatatime - self.__initime)/(self.n - 1)
1238 self.__timeInterval = (self.__lastdatatime - self.__initime)/(self.n - 1)
1238 except:
1239 except:
1239 self.__timeInterval = self.__lastdatatime - self.__initime
1240 self.__timeInterval = self.__lastdatatime - self.__initime
1240
1241
1241 deltatime = datatime -self.__lastdatatime
1242 deltatime = datatime -self.__lastdatatime
1242
1243
1243 if not self.__withOverapping:
1244 if not self.__withOverapping:
1244 self.__initime = datatime
1245 self.__initime = datatime
1245 else:
1246 else:
1246 self.__initime += deltatime
1247 self.__initime += deltatime
1247
1248
1248 return avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc
1249 return avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc
1249
1250
1250 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
1251 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
1251
1252
1252 if n==1:
1253 if n==1:
1253 dataOut.flagNoData = False
1254 dataOut.flagNoData = False
1254 return
1255 return
1255
1256
1256 if not self.__isConfig:
1257 if not self.__isConfig:
1257 self.setup(n, timeInterval, overlapping)
1258 self.setup(n, timeInterval, overlapping)
1258 self.__isConfig = True
1259 self.__isConfig = True
1259
1260
1260 avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
1261 avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
1261 dataOut.data_spc,
1262 dataOut.data_spc,
1262 dataOut.data_cspc,
1263 dataOut.data_cspc,
1263 dataOut.data_dc)
1264 dataOut.data_dc)
1264
1265
1265 # dataOut.timeInterval *= n
1266 # dataOut.timeInterval *= n
1266 dataOut.flagNoData = True
1267 dataOut.flagNoData = True
1267
1268
1268 if self.__dataReady:
1269 if self.__dataReady:
1269
1270
1270 dataOut.data_spc = avgdata_spc
1271 dataOut.data_spc = avgdata_spc
1271 dataOut.data_cspc = avgdata_cspc
1272 dataOut.data_cspc = avgdata_cspc
1272 dataOut.data_dc = avgdata_dc
1273 dataOut.data_dc = avgdata_dc
1273
1274
1274 dataOut.nIncohInt *= self.n
1275 dataOut.nIncohInt *= self.n
1275 dataOut.utctime = avgdatatime
1276 dataOut.utctime = avgdatatime
1276 #dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints
1277 #dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints
1277 dataOut.timeInterval = self.__timeInterval*self.n
1278 dataOut.timeInterval = self.__timeInterval*self.n
1278 dataOut.flagNoData = False
1279 dataOut.flagNoData = False
1279
1280
1280 class ProfileSelector(Operation):
1281 class ProfileSelector(Operation):
1281
1282
1282 profileIndex = None
1283 profileIndex = None
1283 # Tamanho total de los perfiles
1284 # Tamanho total de los perfiles
1284 nProfiles = None
1285 nProfiles = None
1285
1286
1286 def __init__(self):
1287 def __init__(self):
1287
1288
1288 self.profileIndex = 0
1289 self.profileIndex = 0
1289
1290
1290 def incIndex(self):
1291 def incIndex(self):
1291 self.profileIndex += 1
1292 self.profileIndex += 1
1292
1293
1293 if self.profileIndex >= self.nProfiles:
1294 if self.profileIndex >= self.nProfiles:
1294 self.profileIndex = 0
1295 self.profileIndex = 0
1295
1296
1296 def isProfileInRange(self, minIndex, maxIndex):
1297 def isProfileInRange(self, minIndex, maxIndex):
1297
1298
1298 if self.profileIndex < minIndex:
1299 if self.profileIndex < minIndex:
1299 return False
1300 return False
1300
1301
1301 if self.profileIndex > maxIndex:
1302 if self.profileIndex > maxIndex:
1302 return False
1303 return False
1303
1304
1304 return True
1305 return True
1305
1306
1306 def isProfileInList(self, profileList):
1307 def isProfileInList(self, profileList):
1307
1308
1308 if self.profileIndex not in profileList:
1309 if self.profileIndex not in profileList:
1309 return False
1310 return False
1310
1311
1311 return True
1312 return True
1312
1313
1313 def run(self, dataOut, profileList=None, profileRangeList=None):
1314 def run(self, dataOut, profileList=None, profileRangeList=None):
1314
1315
1315 dataOut.flagNoData = True
1316 dataOut.flagNoData = True
1316 self.nProfiles = dataOut.nProfiles
1317 self.nProfiles = dataOut.nProfiles
1317
1318
1318 if profileList != None:
1319 if profileList != None:
1319 if self.isProfileInList(profileList):
1320 if self.isProfileInList(profileList):
1320 dataOut.flagNoData = False
1321 dataOut.flagNoData = False
1321
1322
1322 self.incIndex()
1323 self.incIndex()
1323 return 1
1324 return 1
1324
1325
1325
1326
1326 elif profileRangeList != None:
1327 elif profileRangeList != None:
1327 minIndex = profileRangeList[0]
1328 minIndex = profileRangeList[0]
1328 maxIndex = profileRangeList[1]
1329 maxIndex = profileRangeList[1]
1329 if self.isProfileInRange(minIndex, maxIndex):
1330 if self.isProfileInRange(minIndex, maxIndex):
1330 dataOut.flagNoData = False
1331 dataOut.flagNoData = False
1331
1332
1332 self.incIndex()
1333 self.incIndex()
1333 return 1
1334 return 1
1334
1335
1335 else:
1336 else:
1336 raise ValueError, "ProfileSelector needs profileList or profileRangeList"
1337 raise ValueError, "ProfileSelector needs profileList or profileRangeList"
1337
1338
1338 return 0
1339 return 0
1339
1340
1340 class SpectraHeisProc(ProcessingUnit):
1341 class SpectraHeisProc(ProcessingUnit):
1341 def __init__(self):
1342 def __init__(self):
1342 self.objectDict = {}
1343 self.objectDict = {}
1343 # self.buffer = None
1344 # self.buffer = None
1344 # self.firstdatatime = None
1345 # self.firstdatatime = None
1345 # self.profIndex = 0
1346 # self.profIndex = 0
1346 self.dataOut = SpectraHeis()
1347 self.dataOut = SpectraHeis()
1347
1348
1348 def __updateObjFromInput(self):
1349 def __updateObjFromInput(self):
1349 self.dataOut.timeZone = self.dataIn.timeZone
1350 self.dataOut.timeZone = self.dataIn.timeZone
1350 self.dataOut.dstFlag = self.dataIn.dstFlag
1351 self.dataOut.dstFlag = self.dataIn.dstFlag
1351 self.dataOut.errorCount = self.dataIn.errorCount
1352 self.dataOut.errorCount = self.dataIn.errorCount
1352 self.dataOut.useLocalTime = self.dataIn.useLocalTime
1353 self.dataOut.useLocalTime = self.dataIn.useLocalTime
1353
1354
1354 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()#
1355 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()#
1355 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()#
1356 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()#
1356 self.dataOut.channelList = self.dataIn.channelList
1357 self.dataOut.channelList = self.dataIn.channelList
1357 self.dataOut.heightList = self.dataIn.heightList
1358 self.dataOut.heightList = self.dataIn.heightList
1358 # self.dataOut.dtype = self.dataIn.dtype
1359 # self.dataOut.dtype = self.dataIn.dtype
1359 self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
1360 self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
1360 # self.dataOut.nHeights = self.dataIn.nHeights
1361 # self.dataOut.nHeights = self.dataIn.nHeights
1361 # self.dataOut.nChannels = self.dataIn.nChannels
1362 # self.dataOut.nChannels = self.dataIn.nChannels
1362 self.dataOut.nBaud = self.dataIn.nBaud
1363 self.dataOut.nBaud = self.dataIn.nBaud
1363 self.dataOut.nCode = self.dataIn.nCode
1364 self.dataOut.nCode = self.dataIn.nCode
1364 self.dataOut.code = self.dataIn.code
1365 self.dataOut.code = self.dataIn.code
1365 # self.dataOut.nProfiles = 1
1366 # self.dataOut.nProfiles = 1
1366 # self.dataOut.nProfiles = self.dataOut.nFFTPoints
1367 # self.dataOut.nProfiles = self.dataOut.nFFTPoints
1367 self.dataOut.nFFTPoints = self.dataIn.nHeights
1368 self.dataOut.nFFTPoints = self.dataIn.nHeights
1368 # self.dataOut.channelIndexList = self.dataIn.channelIndexList
1369 # self.dataOut.channelIndexList = self.dataIn.channelIndexList
1369 # self.dataOut.flagNoData = self.dataIn.flagNoData
1370 # self.dataOut.flagNoData = self.dataIn.flagNoData
1370 self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
1371 self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
1371 self.dataOut.utctime = self.dataIn.utctime
1372 self.dataOut.utctime = self.dataIn.utctime
1372 # self.dataOut.utctime = self.firstdatatime
1373 # self.dataOut.utctime = self.firstdatatime
1373 self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
1374 self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
1374 self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
1375 self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
1375 # self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
1376 # self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
1376 self.dataOut.nCohInt = self.dataIn.nCohInt
1377 self.dataOut.nCohInt = self.dataIn.nCohInt
1377 self.dataOut.nIncohInt = 1
1378 self.dataOut.nIncohInt = 1
1378 self.dataOut.ippSeconds= self.dataIn.ippSeconds
1379 self.dataOut.ippSeconds= self.dataIn.ippSeconds
1379 self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
1380 self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
1380
1381
1381 self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nIncohInt
1382 self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nIncohInt
1382 # self.dataOut.set=self.dataIn.set
1383 # self.dataOut.set=self.dataIn.set
1383 # self.dataOut.deltaHeight=self.dataIn.deltaHeight
1384 # self.dataOut.deltaHeight=self.dataIn.deltaHeight
1384
1385
1385
1386
1386 def __getFft(self):
1387 def __getFft(self):
1387
1388
1388 fft_volt = numpy.fft.fft(self.dataIn.data, axis=1)
1389 fft_volt = numpy.fft.fft(self.dataIn.data, axis=1)
1389 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
1390 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
1390 spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))/(self.dataOut.nFFTPoints)
1391 spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))/(self.dataOut.nFFTPoints)
1391 self.dataOut.data_spc = spc
1392 self.dataOut.data_spc = spc
1392
1393
1393 def init(self):
1394 def init(self):
1394
1395
1395 self.dataOut.flagNoData = True
1396 self.dataOut.flagNoData = True
1396
1397
1397 if self.dataIn.type == "SpectraHeis":
1398 if self.dataIn.type == "SpectraHeis":
1398 self.dataOut.copy(self.dataIn)
1399 self.dataOut.copy(self.dataIn)
1399 return
1400 return
1400
1401
1401 if self.dataIn.type == "Voltage":
1402 if self.dataIn.type == "Voltage":
1402 self.__updateObjFromInput()
1403 self.__updateObjFromInput()
1403 self.__getFft()
1404 self.__getFft()
1404 self.dataOut.flagNoData = False
1405 self.dataOut.flagNoData = False
1405
1406
1406 return
1407 return
1407
1408
1408 raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
1409 raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
1409
1410
1410
1411
1411 def selectChannels(self, channelList):
1412 def selectChannels(self, channelList):
1412
1413
1413 channelIndexList = []
1414 channelIndexList = []
1414
1415
1415 for channel in channelList:
1416 for channel in channelList:
1416 index = self.dataOut.channelList.index(channel)
1417 index = self.dataOut.channelList.index(channel)
1417 channelIndexList.append(index)
1418 channelIndexList.append(index)
1418
1419
1419 self.selectChannelsByIndex(channelIndexList)
1420 self.selectChannelsByIndex(channelIndexList)
1420
1421
1421 def selectChannelsByIndex(self, channelIndexList):
1422 def selectChannelsByIndex(self, channelIndexList):
1422 """
1423 """
1423 Selecciona un bloque de datos en base a canales segun el channelIndexList
1424 Selecciona un bloque de datos en base a canales segun el channelIndexList
1424
1425
1425 Input:
1426 Input:
1426 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
1427 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
1427
1428
1428 Affected:
1429 Affected:
1429 self.dataOut.data
1430 self.dataOut.data
1430 self.dataOut.channelIndexList
1431 self.dataOut.channelIndexList
1431 self.dataOut.nChannels
1432 self.dataOut.nChannels
1432 self.dataOut.m_ProcessingHeader.totalSpectra
1433 self.dataOut.m_ProcessingHeader.totalSpectra
1433 self.dataOut.systemHeaderObj.numChannels
1434 self.dataOut.systemHeaderObj.numChannels
1434 self.dataOut.m_ProcessingHeader.blockSize
1435 self.dataOut.m_ProcessingHeader.blockSize
1435
1436
1436 Return:
1437 Return:
1437 None
1438 None
1438 """
1439 """
1439
1440
1440 for channelIndex in channelIndexList:
1441 for channelIndex in channelIndexList:
1441 if channelIndex not in self.dataOut.channelIndexList:
1442 if channelIndex not in self.dataOut.channelIndexList:
1442 print channelIndexList
1443 print channelIndexList
1443 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
1444 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
1444
1445
1445 nChannels = len(channelIndexList)
1446 nChannels = len(channelIndexList)
1446
1447
1447 data_spc = self.dataOut.data_spc[channelIndexList,:]
1448 data_spc = self.dataOut.data_spc[channelIndexList,:]
1448
1449
1449 self.dataOut.data_spc = data_spc
1450 self.dataOut.data_spc = data_spc
1450 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
1451 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
1451
1452
1452 return 1
1453 return 1
1453
1454
1454 class IncohInt4SpectraHeis(Operation):
1455 class IncohInt4SpectraHeis(Operation):
1455
1456
1456 __isConfig = False
1457 __isConfig = False
1457
1458
1458 __profIndex = 0
1459 __profIndex = 0
1459 __withOverapping = False
1460 __withOverapping = False
1460
1461
1461 __byTime = False
1462 __byTime = False
1462 __initime = None
1463 __initime = None
1463 __lastdatatime = None
1464 __lastdatatime = None
1464 __integrationtime = None
1465 __integrationtime = None
1465
1466
1466 __buffer = None
1467 __buffer = None
1467
1468
1468 __dataReady = False
1469 __dataReady = False
1469
1470
1470 n = None
1471 n = None
1471
1472
1472
1473
1473 def __init__(self):
1474 def __init__(self):
1474
1475
1475 self.__isConfig = False
1476 self.__isConfig = False
1476
1477
1477 def setup(self, n=None, timeInterval=None, overlapping=False):
1478 def setup(self, n=None, timeInterval=None, overlapping=False):
1478 """
1479 """
1479 Set the parameters of the integration class.
1480 Set the parameters of the integration class.
1480
1481
1481 Inputs:
1482 Inputs:
1482
1483
1483 n : Number of coherent integrations
1484 n : Number of coherent integrations
1484 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
1485 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
1485 overlapping :
1486 overlapping :
1486
1487
1487 """
1488 """
1488
1489
1489 self.__initime = None
1490 self.__initime = None
1490 self.__lastdatatime = 0
1491 self.__lastdatatime = 0
1491 self.__buffer = None
1492 self.__buffer = None
1492 self.__dataReady = False
1493 self.__dataReady = False
1493
1494
1494
1495
1495 if n == None and timeInterval == None:
1496 if n == None and timeInterval == None:
1496 raise ValueError, "n or timeInterval should be specified ..."
1497 raise ValueError, "n or timeInterval should be specified ..."
1497
1498
1498 if n != None:
1499 if n != None:
1499 self.n = n
1500 self.n = n
1500 self.__byTime = False
1501 self.__byTime = False
1501 else:
1502 else:
1502 self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
1503 self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
1503 self.n = 9999
1504 self.n = 9999
1504 self.__byTime = True
1505 self.__byTime = True
1505
1506
1506 if overlapping:
1507 if overlapping:
1507 self.__withOverapping = True
1508 self.__withOverapping = True
1508 self.__buffer = None
1509 self.__buffer = None
1509 else:
1510 else:
1510 self.__withOverapping = False
1511 self.__withOverapping = False
1511 self.__buffer = 0
1512 self.__buffer = 0
1512
1513
1513 self.__profIndex = 0
1514 self.__profIndex = 0
1514
1515
1515 def putData(self, data):
1516 def putData(self, data):
1516
1517
1517 """
1518 """
1518 Add a profile to the __buffer and increase in one the __profileIndex
1519 Add a profile to the __buffer and increase in one the __profileIndex
1519
1520
1520 """
1521 """
1521
1522
1522 if not self.__withOverapping:
1523 if not self.__withOverapping:
1523 self.__buffer += data.copy()
1524 self.__buffer += data.copy()
1524 self.__profIndex += 1
1525 self.__profIndex += 1
1525 return
1526 return
1526
1527
1527 #Overlapping data
1528 #Overlapping data
1528 nChannels, nHeis = data.shape
1529 nChannels, nHeis = data.shape
1529 data = numpy.reshape(data, (1, nChannels, nHeis))
1530 data = numpy.reshape(data, (1, nChannels, nHeis))
1530
1531
1531 #If the buffer is empty then it takes the data value
1532 #If the buffer is empty then it takes the data value
1532 if self.__buffer == None:
1533 if self.__buffer == None:
1533 self.__buffer = data
1534 self.__buffer = data
1534 self.__profIndex += 1
1535 self.__profIndex += 1
1535 return
1536 return
1536
1537
1537 #If the buffer length is lower than n then stakcing the data value
1538 #If the buffer length is lower than n then stakcing the data value
1538 if self.__profIndex < self.n:
1539 if self.__profIndex < self.n:
1539 self.__buffer = numpy.vstack((self.__buffer, data))
1540 self.__buffer = numpy.vstack((self.__buffer, data))
1540 self.__profIndex += 1
1541 self.__profIndex += 1
1541 return
1542 return
1542
1543
1543 #If the buffer length is equal to n then replacing the last buffer value with the data value
1544 #If the buffer length is equal to n then replacing the last buffer value with the data value
1544 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
1545 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
1545 self.__buffer[self.n-1] = data
1546 self.__buffer[self.n-1] = data
1546 self.__profIndex = self.n
1547 self.__profIndex = self.n
1547 return
1548 return
1548
1549
1549
1550
1550 def pushData(self):
1551 def pushData(self):
1551 """
1552 """
1552 Return the sum of the last profiles and the profiles used in the sum.
1553 Return the sum of the last profiles and the profiles used in the sum.
1553
1554
1554 Affected:
1555 Affected:
1555
1556
1556 self.__profileIndex
1557 self.__profileIndex
1557
1558
1558 """
1559 """
1559
1560
1560 if not self.__withOverapping:
1561 if not self.__withOverapping:
1561 data = self.__buffer
1562 data = self.__buffer
1562 n = self.__profIndex
1563 n = self.__profIndex
1563
1564
1564 self.__buffer = 0
1565 self.__buffer = 0
1565 self.__profIndex = 0
1566 self.__profIndex = 0
1566
1567
1567 return data, n
1568 return data, n
1568
1569
1569 #Integration with Overlapping
1570 #Integration with Overlapping
1570 data = numpy.sum(self.__buffer, axis=0)
1571 data = numpy.sum(self.__buffer, axis=0)
1571 n = self.__profIndex
1572 n = self.__profIndex
1572
1573
1573 return data, n
1574 return data, n
1574
1575
1575 def byProfiles(self, data):
1576 def byProfiles(self, data):
1576
1577
1577 self.__dataReady = False
1578 self.__dataReady = False
1578 avgdata = None
1579 avgdata = None
1579 n = None
1580 n = None
1580
1581
1581 self.putData(data)
1582 self.putData(data)
1582
1583
1583 if self.__profIndex == self.n:
1584 if self.__profIndex == self.n:
1584
1585
1585 avgdata, n = self.pushData()
1586 avgdata, n = self.pushData()
1586 self.__dataReady = True
1587 self.__dataReady = True
1587
1588
1588 return avgdata
1589 return avgdata
1589
1590
1590 def byTime(self, data, datatime):
1591 def byTime(self, data, datatime):
1591
1592
1592 self.__dataReady = False
1593 self.__dataReady = False
1593 avgdata = None
1594 avgdata = None
1594 n = None
1595 n = None
1595
1596
1596 self.putData(data)
1597 self.putData(data)
1597
1598
1598 if (datatime - self.__initime) >= self.__integrationtime:
1599 if (datatime - self.__initime) >= self.__integrationtime:
1599 avgdata, n = self.pushData()
1600 avgdata, n = self.pushData()
1600 self.n = n
1601 self.n = n
1601 self.__dataReady = True
1602 self.__dataReady = True
1602
1603
1603 return avgdata
1604 return avgdata
1604
1605
1605 def integrate(self, data, datatime=None):
1606 def integrate(self, data, datatime=None):
1606
1607
1607 if self.__initime == None:
1608 if self.__initime == None:
1608 self.__initime = datatime
1609 self.__initime = datatime
1609
1610
1610 if self.__byTime:
1611 if self.__byTime:
1611 avgdata = self.byTime(data, datatime)
1612 avgdata = self.byTime(data, datatime)
1612 else:
1613 else:
1613 avgdata = self.byProfiles(data)
1614 avgdata = self.byProfiles(data)
1614
1615
1615
1616
1616 self.__lastdatatime = datatime
1617 self.__lastdatatime = datatime
1617
1618
1618 if avgdata == None:
1619 if avgdata == None:
1619 return None, None
1620 return None, None
1620
1621
1621 avgdatatime = self.__initime
1622 avgdatatime = self.__initime
1622
1623
1623 deltatime = datatime -self.__lastdatatime
1624 deltatime = datatime -self.__lastdatatime
1624
1625
1625 if not self.__withOverapping:
1626 if not self.__withOverapping:
1626 self.__initime = datatime
1627 self.__initime = datatime
1627 else:
1628 else:
1628 self.__initime += deltatime
1629 self.__initime += deltatime
1629
1630
1630 return avgdata, avgdatatime
1631 return avgdata, avgdatatime
1631
1632
1632 def run(self, dataOut, **kwargs):
1633 def run(self, dataOut, **kwargs):
1633
1634
1634 if not self.__isConfig:
1635 if not self.__isConfig:
1635 self.setup(**kwargs)
1636 self.setup(**kwargs)
1636 self.__isConfig = True
1637 self.__isConfig = True
1637
1638
1638 avgdata, avgdatatime = self.integrate(dataOut.data_spc, dataOut.utctime)
1639 avgdata, avgdatatime = self.integrate(dataOut.data_spc, dataOut.utctime)
1639
1640
1640 # dataOut.timeInterval *= n
1641 # dataOut.timeInterval *= n
1641 dataOut.flagNoData = True
1642 dataOut.flagNoData = True
1642
1643
1643 if self.__dataReady:
1644 if self.__dataReady:
1644 dataOut.data_spc = avgdata
1645 dataOut.data_spc = avgdata
1645 dataOut.nIncohInt *= self.n
1646 dataOut.nIncohInt *= self.n
1646 # dataOut.nCohInt *= self.n
1647 # dataOut.nCohInt *= self.n
1647 dataOut.utctime = avgdatatime
1648 dataOut.utctime = avgdatatime
1648 dataOut.timeInterval = dataOut.ippSeconds * dataOut.nIncohInt
1649 dataOut.timeInterval = dataOut.ippSeconds * dataOut.nIncohInt
1649 # dataOut.timeInterval = self.__timeInterval*self.n
1650 # dataOut.timeInterval = self.__timeInterval*self.n
1650 dataOut.flagNoData = False
1651 dataOut.flagNoData = False
1651
1652
1652
1653
1653
1654
1654
1655
1655 No newline at end of file
1656
General Comments 0
You need to be logged in to leave comments. Login now