##// END OF EJS Templates
schain
RSS
HeaderIO: Se cambio el tipo de dato de los atributos del header de numpy a enteros
Miguel Valdez -
r217:30544927374e
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,505 +1,505
1 1 '''
2 2
3 3 $Author: murco $
4 4 $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
5 5 '''
6 6
7 7 import numpy
8 8 import copy
9 9
10 10 class Header:
11 11
12 12 def __init__(self):
13 13 raise
14 14
15 15 def copy(self):
16 16 return copy.deepcopy(self)
17 17
18 18 def read():
19 19 pass
20 20
21 21 def write():
22 22 pass
23 23
24 24 class BasicHeader(Header):
25 25
26 26 size = None
27 27 version = None
28 28 dataBlock = None
29 29 utc = None
30 30 miliSecond = None
31 31 timeZone = None
32 32 dstFlag = None
33 33 errorCount = None
34 34 struct = None
35 35
36 36 def __init__(self):
37 37
38 38 self.size = 0
39 39 self.version = 0
40 40 self.dataBlock = 0
41 41 self.utc = 0
42 42 self.miliSecond = 0
43 43 self.timeZone = 0
44 44 self.dstFlag = 0
45 45 self.errorCount = 0
46 46 self.struct = numpy.dtype([
47 47 ('nSize','<u4'),
48 48 ('nVersion','<u2'),
49 49 ('nDataBlockId','<u4'),
50 50 ('nUtime','<u4'),
51 51 ('nMilsec','<u2'),
52 52 ('nTimezone','<i2'),
53 53 ('nDstflag','<i2'),
54 54 ('nErrorCount','<u4')
55 55 ])
56 56
57 57
58 58 def read(self, fp):
59 59 try:
60 60 header = numpy.fromfile(fp, self.struct,1)
61 self.size = header['nSize'][0]
62 self.version = header['nVersion'][0]
63 self.dataBlock = header['nDataBlockId'][0]
64 self.utc = header['nUtime'][0]
65 self.miliSecond = header['nMilsec'][0]
66 self.timeZone = header['nTimezone'][0]
67 self.dstFlag = header['nDstflag'][0]
68 self.errorCount = header['nErrorCount'][0]
61 self.size = int(header['nSize'][0])
62 self.version = int(header['nVersion'][0])
63 self.dataBlock = int(header['nDataBlockId'][0])
64 self.utc = int(header['nUtime'][0])
65 self.miliSecond = int(header['nMilsec'][0])
66 self.timeZone = int(header['nTimezone'][0])
67 self.dstFlag = int(header['nDstflag'][0])
68 self.errorCount = int(header['nErrorCount'][0])
69 69 except:
70 70 return 0
71 71
72 72 return 1
73 73
74 74 def write(self, fp):
75 75 headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
76 76 header = numpy.array(headerTuple,self.struct)
77 77 header.tofile(fp)
78 78
79 79 return 1
80 80
81 81 class SystemHeader(Header):
82 82
83 83 size = None
84 84 nSamples = None
85 85 nProfiles = None
86 86 nChannels = None
87 87 adcResolution = None
88 88 pciDioBusWidth = None
89 89 struct = None
90 90
91 91 def __init__(self):
92 92 self.size = 0
93 93 self.nSamples = 0
94 94 self.nProfiles = 0
95 95 self.nChannels = 0
96 96 self.adcResolution = 0
97 97 self.pciDioBusWidth = 0
98 98 self.struct = numpy.dtype([
99 99 ('nSize','<u4'),
100 100 ('nNumSamples','<u4'),
101 101 ('nNumProfiles','<u4'),
102 102 ('nNumChannels','<u4'),
103 103 ('nADCResolution','<u4'),
104 104 ('nPCDIOBusWidth','<u4'),
105 105 ])
106 106
107 107
108 108 def read(self, fp):
109 109 try:
110 110 header = numpy.fromfile(fp,self.struct,1)
111 111 self.size = header['nSize'][0]
112 112 self.nSamples = header['nNumSamples'][0]
113 113 self.nProfiles = header['nNumProfiles'][0]
114 114 self.nChannels = header['nNumChannels'][0]
115 115 self.adcResolution = header['nADCResolution'][0]
116 116 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
117 117 except:
118 118 return 0
119 119
120 120 return 1
121 121
122 122 def write(self, fp):
123 123 headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
124 124 header = numpy.array(headerTuple,self.struct)
125 125 header.tofile(fp)
126 126
127 127 return 1
128 128
129 129 class RadarControllerHeader(Header):
130 130
131 131 size = None
132 132 expType = None
133 133 nTx = None
134 134 ipp = None
135 135 txA = None
136 136 txB = None
137 137 nWindows = None
138 138 numTaus = None
139 139 codeType = None
140 140 line6Function = None
141 141 line5Function = None
142 142 fClock = None
143 143 prePulseBefore = None
144 144 prePulserAfter = None
145 145 rangeIpp = None
146 146 rangeTxA = None
147 147 rangeTxB = None
148 148 struct = None
149 149
150 150 def __init__(self):
151 151 self.size = 0
152 152 self.expType = 0
153 153 self.nTx = 0
154 154 self.ipp = 0
155 155 self.txA = 0
156 156 self.txB = 0
157 157 self.nWindows = 0
158 158 self.numTaus = 0
159 159 self.codeType = 0
160 160 self.line6Function = 0
161 161 self.line5Function = 0
162 162 self.fClock = 0
163 163 self.prePulseBefore = 0
164 164 self.prePulserAfter = 0
165 165 self.rangeIpp = 0
166 166 self.rangeTxA = 0
167 167 self.rangeTxB = 0
168 168 self.struct = numpy.dtype([
169 169 ('nSize','<u4'),
170 170 ('nExpType','<u4'),
171 171 ('nNTx','<u4'),
172 172 ('fIpp','<f4'),
173 173 ('fTxA','<f4'),
174 174 ('fTxB','<f4'),
175 175 ('nNumWindows','<u4'),
176 176 ('nNumTaus','<u4'),
177 177 ('nCodeType','<u4'),
178 178 ('nLine6Function','<u4'),
179 179 ('nLine5Function','<u4'),
180 180 ('fClock','<f4'),
181 181 ('nPrePulseBefore','<u4'),
182 182 ('nPrePulseAfter','<u4'),
183 183 ('sRangeIPP','<a20'),
184 184 ('sRangeTxA','<a20'),
185 185 ('sRangeTxB','<a20'),
186 186 ])
187 187
188 188 self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
189 189
190 190 self.samplingWindow = None
191 191 self.nHeights = None
192 192 self.firstHeight = None
193 193 self.deltaHeight = None
194 194 self.samplesWin = None
195 195
196 196 self.nCode = None
197 197 self.nBaud = None
198 198 self.code = None
199 199 self.flip1 = None
200 200 self.flip2 = None
201 201
202 202 self.dynamic = numpy.array([],numpy.dtype('byte'))
203 203
204 204
205 205 def read(self, fp):
206 206 try:
207 207 startFp = fp.tell()
208 208 header = numpy.fromfile(fp,self.struct,1)
209 self.size = header['nSize'][0]
210 self.expType = header['nExpType'][0]
211 self.nTx = header['nNTx'][0]
212 self.ipp = header['fIpp'][0]
213 self.txA = header['fTxA'][0]
214 self.txB = header['fTxB'][0]
215 self.nWindows = header['nNumWindows'][0]
216 self.numTaus = header['nNumTaus'][0]
217 self.codeType = header['nCodeType'][0]
218 self.line6Function = header['nLine6Function'][0]
219 self.line5Function = header['nLine5Function'][0]
220 self.fClock = header['fClock'][0]
221 self.prePulseBefore = header['nPrePulseBefore'][0]
222 self.prePulserAfter = header['nPrePulseAfter'][0]
209 self.size = int(header['nSize'][0])
210 self.expType = int(header['nExpType'][0])
211 self.nTx = int(header['nNTx'][0])
212 self.ipp = float(header['fIpp'][0])
213 self.txA = float(header['fTxA'][0])
214 self.txB = float(header['fTxB'][0])
215 self.nWindows = int(header['nNumWindows'][0])
216 self.numTaus = int(header['nNumTaus'][0])
217 self.codeType = int(header['nCodeType'][0])
218 self.line6Function = int(header['nLine6Function'][0])
219 self.line5Function = int(header['nLine5Function'][0])
220 self.fClock = float(header['fClock'][0])
221 self.prePulseBefore = int(header['nPrePulseBefore'][0])
222 self.prePulserAfter = int(header['nPrePulseAfter'][0])
223 223 self.rangeIpp = header['sRangeIPP'][0]
224 224 self.rangeTxA = header['sRangeTxA'][0]
225 225 self.rangeTxB = header['sRangeTxB'][0]
226 226 # jump Dynamic Radar Controller Header
227 227 jumpFp = self.size - 116
228 228 self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
229 229 #pointer backward to dynamic header and read
230 230 backFp = fp.tell() - jumpFp
231 231 fp.seek(backFp)
232 232
233 233 self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
234 self.nHeights = numpy.sum(self.samplingWindow['nsa'])
234 self.nHeights = int(numpy.sum(self.samplingWindow['nsa']))
235 235 self.firstHeight = self.samplingWindow['h0']
236 236 self.deltaHeight = self.samplingWindow['dh']
237 237 self.samplesWin = self.samplingWindow['nsa']
238 238
239 239 self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
240 240
241 241 if self.codeType != 0:
242 self.nCode = numpy.fromfile(fp,'<u4',1)
243 self.nBaud = numpy.fromfile(fp,'<u4',1)
242 self.nCode = int(numpy.fromfile(fp,'<u4',1))
243 self.nBaud = int(numpy.fromfile(fp,'<u4',1))
244 244 self.code = numpy.empty([self.nCode,self.nBaud],dtype='u1')
245 245 tempList = []
246 246 for ic in range(self.nCode):
247 247 temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.nBaud/32.))
248 248 tempList.append(temp)
249 249 self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.nBaud:]
250 250 self.code = 2.0*self.code - 1.0
251 251
252 252 if self.line5Function == RCfunction.FLIP:
253 253 self.flip1 = numpy.fromfile(fp,'<u4',1)
254 254
255 255 if self.line6Function == RCfunction.FLIP:
256 256 self.flip2 = numpy.fromfile(fp,'<u4',1)
257 257
258 258 endFp = self.size + startFp
259 259 jumpFp = endFp - fp.tell()
260 260 if jumpFp > 0:
261 261 fp.seek(jumpFp)
262 262
263 263 except:
264 264 return 0
265 265
266 266 return 1
267 267
268 268 def write(self, fp):
269 269 headerTuple = (self.size,
270 270 self.expType,
271 271 self.nTx,
272 272 self.ipp,
273 273 self.txA,
274 274 self.txB,
275 275 self.nWindows,
276 276 self.numTaus,
277 277 self.codeType,
278 278 self.line6Function,
279 279 self.line5Function,
280 280 self.fClock,
281 281 self.prePulseBefore,
282 282 self.prePulserAfter,
283 283 self.rangeIpp,
284 284 self.rangeTxA,
285 285 self.rangeTxB)
286 286
287 287 header = numpy.array(headerTuple,self.struct)
288 288 header.tofile(fp)
289 289
290 290 dynamic = self.dynamic
291 291 dynamic.tofile(fp)
292 292
293 293 return 1
294 294
295 295
296 296
297 297 class ProcessingHeader(Header):
298 298
299 299 size = None
300 300 dtype = None
301 301 blockSize = None
302 302 profilesPerBlock = None
303 303 dataBlocksPerFile = None
304 304 nWindows = None
305 305 processFlags = None
306 306 nCohInt = None
307 307 nIncohInt = None
308 308 totalSpectra = None
309 309 struct = None
310 310 flag_dc = None
311 311 flag_cspc = None
312 312
313 313 def __init__(self):
314 314 self.size = 0
315 315 self.dtype = 0
316 316 self.blockSize = 0
317 317 self.profilesPerBlock = 0
318 318 self.dataBlocksPerFile = 0
319 319 self.nWindows = 0
320 320 self.processFlags = 0
321 321 self.nCohInt = 0
322 322 self.nIncohInt = 0
323 323 self.totalSpectra = 0
324 324 self.struct = numpy.dtype([
325 325 ('nSize','<u4'),
326 326 ('nDataType','<u4'),
327 327 ('nSizeOfDataBlock','<u4'),
328 328 ('nProfilesperBlock','<u4'),
329 329 ('nDataBlocksperFile','<u4'),
330 330 ('nNumWindows','<u4'),
331 331 ('nProcessFlags','<u4'),
332 332 ('nCoherentIntegrations','<u4'),
333 333 ('nIncoherentIntegrations','<u4'),
334 334 ('nTotalSpectra','<u4')
335 335 ])
336 336 self.samplingWindow = 0
337 337 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
338 338 self.nHeights = 0
339 339 self.firstHeight = 0
340 340 self.deltaHeight = 0
341 341 self.samplesWin = 0
342 342 self.spectraComb = 0
343 343 self.nCode = None
344 344 self.code = None
345 345 self.nBaud = None
346 346 self.shif_fft = False
347 347 self.flag_dc = False
348 348 self.flag_cspc = False
349 349
350 350 def read(self, fp):
351 351 try:
352 352 header = numpy.fromfile(fp,self.struct,1)
353 self.size = header['nSize'][0]
354 self.dtype = header['nDataType'][0]
355 self.blockSize = header['nSizeOfDataBlock'][0]
356 self.profilesPerBlock = header['nProfilesperBlock'][0]
357 self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
358 self.nWindows = header['nNumWindows'][0]
359 self.processFlags = header['nProcessFlags']
360 self.nCohInt = header['nCoherentIntegrations'][0]
361 self.nIncohInt = header['nIncoherentIntegrations'][0]
362 self.totalSpectra = header['nTotalSpectra'][0]
353 self.size = int(header['nSize'][0])
354 self.dtype = int(header['nDataType'][0])
355 self.blockSize = int(header['nSizeOfDataBlock'][0])
356 self.profilesPerBlock = int(header['nProfilesperBlock'][0])
357 self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
358 self.nWindows = int(header['nNumWindows'][0])
359 self.processFlags = int(header['nProcessFlags'])
360 self.nCohInt = int(header['nCoherentIntegrations'][0])
361 self.nIncohInt = int(header['nIncoherentIntegrations'][0])
362 self.totalSpectra = int(header['nTotalSpectra'][0])
363 363 self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
364 self.nHeights = numpy.sum(self.samplingWindow['nsa'])
365 self.firstHeight = self.samplingWindow['h0'][0]
366 self.deltaHeight = self.samplingWindow['dh'][0]
364 self.nHeights = int(numpy.sum(self.samplingWindow['nsa']))
365 self.firstHeight = int(self.samplingWindow['h0'][0])
366 self.deltaHeight = int(self.samplingWindow['dh'][0])
367 367 self.samplesWin = self.samplingWindow['nsa']
368 368 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
369 369
370 370 if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
371 self.nCode = numpy.fromfile(fp,'<u4',1)
372 self.nBaud = numpy.fromfile(fp,'<u4',1)
371 self.nCode = int(numpy.fromfile(fp,'<u4',1))
372 self.nBaud = int(numpy.fromfile(fp,'<u4',1))
373 373 self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nBaud,self.nCode)
374 374
375 375 if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
376 376 self.shif_fft = True
377 377 else:
378 378 self.shif_fft = False
379 379
380 380 if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
381 381 self.flag_dc = True
382 382
383 383 nChannels = 0
384 384 nPairs = 0
385 385 pairList = []
386 386
387 387 for i in range( 0, self.totalSpectra*2, 2 ):
388 388 if self.spectraComb[i] == self.spectraComb[i+1]:
389 389 nChannels = nChannels + 1 #par de canales iguales
390 390 else:
391 391 nPairs = nPairs + 1 #par de canales diferentes
392 392 pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
393 393
394 394 self.flag_cspc = False
395 395 if nPairs > 0:
396 396 self.flag_cspc = True
397 397
398 398 except:
399 399 return 0
400 400
401 401 return 1
402 402
403 403 def write(self, fp):
404 404 headerTuple = (self.size,
405 405 self.dtype,
406 406 self.blockSize,
407 407 self.profilesPerBlock,
408 408 self.dataBlocksPerFile,
409 409 self.nWindows,
410 410 self.processFlags,
411 411 self.nCohInt,
412 412 self.nIncohInt,
413 413 self.totalSpectra)
414 414
415 415 header = numpy.array(headerTuple,self.struct)
416 416 header.tofile(fp)
417 417
418 418 if self.nWindows != 0:
419 419 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
420 420 samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
421 421 samplingWindow.tofile(fp)
422 422
423 423
424 424 if self.totalSpectra != 0:
425 425 spectraComb = numpy.array([],numpy.dtype('u1'))
426 426 spectraComb = self.spectraComb
427 427 spectraComb.tofile(fp)
428 428
429 429
430 430 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
431 431 nCode = self.nCode #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
432 432 nCode.tofile(fp)
433 433
434 434 nBaud = self.nBaud
435 435 nBaud.tofile(fp)
436 436
437 437 code = self.code.reshape(nCode*nBaud)
438 438 code.tofile(fp)
439 439
440 440 return 1
441 441
442 442 class RCfunction:
443 443 NONE=0
444 444 FLIP=1
445 445 CODE=2
446 446 SAMPLING=3
447 447 LIN6DIV256=4
448 448 SYNCHRO=5
449 449
450 450 class nCodeType:
451 451 NONE=0
452 452 USERDEFINE=1
453 453 BARKER2=2
454 454 BARKER3=3
455 455 BARKER4=4
456 456 BARKER5=5
457 457 BARKER7=6
458 458 BARKER11=7
459 459 BARKER13=8
460 460 AC128=9
461 461 COMPLEMENTARYCODE2=10
462 462 COMPLEMENTARYCODE4=11
463 463 COMPLEMENTARYCODE8=12
464 464 COMPLEMENTARYCODE16=13
465 465 COMPLEMENTARYCODE32=14
466 466 COMPLEMENTARYCODE64=15
467 467 COMPLEMENTARYCODE128=16
468 468 CODE_BINARY28=17
469 469
470 470 class PROCFLAG:
471 471 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
472 472 DECODE_DATA = numpy.uint32(0x00000002)
473 473 SPECTRA_CALC = numpy.uint32(0x00000004)
474 474 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
475 475 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
476 476 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
477 477
478 478 DATATYPE_CHAR = numpy.uint32(0x00000040)
479 479 DATATYPE_SHORT = numpy.uint32(0x00000080)
480 480 DATATYPE_LONG = numpy.uint32(0x00000100)
481 481 DATATYPE_INT64 = numpy.uint32(0x00000200)
482 482 DATATYPE_FLOAT = numpy.uint32(0x00000400)
483 483 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
484 484
485 485 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
486 486 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
487 487 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
488 488
489 489 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
490 490 DEFLIP_DATA = numpy.uint32(0x00010000)
491 491 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
492 492
493 493 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
494 494 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
495 495 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
496 496 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
497 497 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
498 498
499 499 EXP_NAME_ESP = numpy.uint32(0x00200000)
500 500 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
501 501
502 502 OPERATION_MASK = numpy.uint32(0x0000003F)
503 503 DATATYPE_MASK = numpy.uint32(0x00000FC0)
504 504 DATAARRANGE_MASK = numpy.uint32(0x00007000)
505 505 ACQ_SYS_MASK = numpy.uint32(0x001C0000) No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,903 +1,903
1 1 '''
2 2
3 3 $Author: dsuarez $
4 4 $Id: Processor.py 1 2012-11-12 18:56:07Z dsuarez $
5 5 '''
6 6 import os
7 7 import numpy
8 8 import datetime
9 9 import time
10 10
11 11 from jrodata import *
12 12 from jrodataIO import *
13 13 from jroplot import *
14 14
15 15 class ProcessingUnit:
16 16
17 17 """
18 18 Esta es la clase base para el procesamiento de datos.
19 19
20 20 Contiene el metodo "call" para llamar operaciones. Las operaciones pueden ser:
21 21 - Metodos internos (callMethod)
22 22 - Objetos del tipo Operation (callObject). Antes de ser llamados, estos objetos
23 23 tienen que ser agreagados con el metodo "add".
24 24
25 25 """
26 26 # objeto de datos de entrada (Voltage, Spectra o Correlation)
27 27 dataIn = None
28 28
29 29 # objeto de datos de entrada (Voltage, Spectra o Correlation)
30 30 dataOut = None
31 31
32 32
33 33 objectDict = None
34 34
35 35 def __init__(self):
36 36
37 37 self.objectDict = {}
38 38
39 39 def init(self):
40 40
41 41 raise ValueError, "Not implemented"
42 42
43 43 def addOperation(self, object, objId):
44 44
45 45 """
46 46 Agrega el objeto "object" a la lista de objetos "self.objectList" y retorna el
47 47 identificador asociado a este objeto.
48 48
49 49 Input:
50 50
51 51 object : objeto de la clase "Operation"
52 52
53 53 Return:
54 54
55 55 objId : identificador del objeto, necesario para ejecutar la operacion
56 56 """
57 57
58 58 self.objectDict[objId] = object
59 59
60 60 return objId
61 61
62 62 def operation(self, **kwargs):
63 63
64 64 """
65 65 Operacion directa sobre la data (dataout.data). Es necesario actualizar los valores de los
66 66 atributos del objeto dataOut
67 67
68 68 Input:
69 69
70 70 **kwargs : Diccionario de argumentos de la funcion a ejecutar
71 71 """
72 72
73 73 raise ValueError, "ImplementedError"
74 74
75 75 def callMethod(self, name, **kwargs):
76 76
77 77 """
78 78 Ejecuta el metodo con el nombre "name" y con argumentos **kwargs de la propia clase.
79 79
80 80 Input:
81 81 name : nombre del metodo a ejecutar
82 82
83 83 **kwargs : diccionario con los nombres y valores de la funcion a ejecutar.
84 84
85 85 """
86 86 if name != 'run':
87 87
88 88 if name == 'init' and self.dataIn.isEmpty():
89 89 self.dataOut.flagNoData = True
90 90 return False
91 91
92 92 if name != 'init' and self.dataOut.isEmpty():
93 93 return False
94 94
95 95 methodToCall = getattr(self, name)
96 96
97 97 methodToCall(**kwargs)
98 98
99 99 if name != 'run':
100 100 return True
101 101
102 102 if self.dataOut.isEmpty():
103 103 return False
104 104
105 105 return True
106 106
107 107 def callObject(self, objId, **kwargs):
108 108
109 109 """
110 110 Ejecuta la operacion asociada al identificador del objeto "objId"
111 111
112 112 Input:
113 113
114 114 objId : identificador del objeto a ejecutar
115 115
116 116 **kwargs : diccionario con los nombres y valores de la funcion a ejecutar.
117 117
118 118 Return:
119 119
120 120 None
121 121 """
122 122
123 123 if self.dataOut.isEmpty():
124 124 return False
125 125
126 126 object = self.objectDict[objId]
127 127
128 128 object.run(self.dataOut, **kwargs)
129 129
130 130 return True
131 131
132 132 def call(self, operationConf, **kwargs):
133 133
134 134 """
135 135 Return True si ejecuta la operacion "operationConf.name" con los
136 136 argumentos "**kwargs". False si la operacion no se ha ejecutado.
137 137 La operacion puede ser de dos tipos:
138 138
139 139 1. Un metodo propio de esta clase:
140 140
141 141 operation.type = "self"
142 142
143 143 2. El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
144 144 operation.type = "other".
145 145
146 146 Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
147 147 "addOperation" e identificado con el operation.id
148 148
149 149
150 150 con el id de la operacion.
151 151
152 152 Input:
153 153
154 154 Operation : Objeto del tipo operacion con los atributos: name, type y id.
155 155
156 156 """
157 157
158 158 if operationConf.type == 'self':
159 159 sts = self.callMethod(operationConf.name, **kwargs)
160 160
161 161 if operationConf.type == 'other':
162 162 sts = self.callObject(operationConf.id, **kwargs)
163 163
164 164 return sts
165 165
166 166 def setInput(self, dataIn):
167 167
168 168 self.dataIn = dataIn
169 169
170 170 def getOutput(self):
171 171
172 172 return self.dataOut
173 173
174 174 class Operation():
175 175
176 176 """
177 177 Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
178 178 y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
179 179 acumulacion dentro de esta clase
180 180
181 181 Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
182 182
183 183 """
184 184
185 185 __buffer = None
186 186 __isConfig = False
187 187
188 188 def __init__(self):
189 189
190 190 pass
191 191
192 192 def run(self, dataIn, **kwargs):
193 193
194 194 """
195 195 Realiza las operaciones necesarias sobre la dataIn.data y actualiza los atributos del objeto dataIn.
196 196
197 197 Input:
198 198
199 199 dataIn : objeto del tipo JROData
200 200
201 201 Return:
202 202
203 203 None
204 204
205 205 Affected:
206 206 __buffer : buffer de recepcion de datos.
207 207
208 208 """
209 209
210 210 raise ValueError, "ImplementedError"
211 211
212 212 class VoltageProc(ProcessingUnit):
213 213
214 214
215 215 def __init__(self):
216 216
217 217 self.objectDict = {}
218 218 self.dataOut = Voltage()
219 219
220 220 def init(self):
221 221
222 222 self.dataOut.copy(self.dataIn)
223 223 # No necesita copiar en cada init() los atributos de dataIn
224 224 # la copia deberia hacerse por cada nuevo bloque de datos
225 225
226 226 def selectChannels(self, channelList):
227 227
228 228 channelIndexList = []
229 229
230 230 for channel in channelList:
231 231 index = self.dataOut.channelList.index(channel)
232 232 channelIndexList.append(index)
233 233
234 234 self.selectChannelsByIndex(channelIndexList)
235 235
236 236 def selectChannelsByIndex(self, channelIndexList):
237 237 """
238 238 Selecciona un bloque de datos en base a canales segun el channelIndexList
239 239
240 240 Input:
241 241 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
242 242
243 243 Affected:
244 244 self.dataOut.data
245 245 self.dataOut.channelIndexList
246 246 self.dataOut.nChannels
247 247 self.dataOut.m_ProcessingHeader.totalSpectra
248 248 self.dataOut.systemHeaderObj.numChannels
249 249 self.dataOut.m_ProcessingHeader.blockSize
250 250
251 251 Return:
252 252 None
253 253 """
254 254
255 255 for channelIndex in channelIndexList:
256 256 if channelIndex not in self.dataOut.channelIndexList:
257 257 print channelIndexList
258 258 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
259 259
260 260 nChannels = len(channelIndexList)
261 261
262 262 data = self.dataOut.data[channelIndexList,:]
263 263
264 264 self.dataOut.data = data
265 265 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
266 266 # self.dataOut.nChannels = nChannels
267 267
268 268 return 1
269 269
270 270 class CohInt(Operation):
271 271
272 272 __profIndex = 0
273 273 __withOverapping = False
274 274
275 275 __byTime = False
276 276 __initime = None
277 277 __lastdatatime = None
278 278 __integrationtime = None
279 279
280 280 __buffer = None
281 281
282 282 __dataReady = False
283 283
284 284 n = None
285 285
286 286
287 287 def __init__(self):
288 288
289 289 self.__isConfig = False
290 290
291 291 def setup(self, n=None, timeInterval=None, overlapping=False):
292 292 """
293 293 Set the parameters of the integration class.
294 294
295 295 Inputs:
296 296
297 297 n : Number of coherent integrations
298 298 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
299 299 overlapping :
300 300
301 301 """
302 302
303 303 self.__initime = None
304 304 self.__lastdatatime = 0
305 305 self.__buffer = None
306 306 self.__dataReady = False
307 307
308 308
309 309 if n == None and timeInterval == None:
310 310 raise ValueError, "n or timeInterval should be specified ..."
311 311
312 312 if n != None:
313 313 self.n = n
314 314 self.__byTime = False
315 315 else:
316 316 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
317 317 self.n = 9999
318 318 self.__byTime = True
319 319
320 320 if overlapping:
321 321 self.__withOverapping = True
322 322 self.__buffer = None
323 323 else:
324 324 self.__withOverapping = False
325 325 self.__buffer = 0
326 326
327 327 self.__profIndex = 0
328 328
329 329 def putData(self, data):
330 330
331 331 """
332 332 Add a profile to the __buffer and increase in one the __profileIndex
333 333
334 334 """
335 335
336 336 if not self.__withOverapping:
337 337 self.__buffer += data.copy()
338 338 self.__profIndex += 1
339 339 return
340 340
341 341 #Overlapping data
342 342 nChannels, nHeis = data.shape
343 343 data = numpy.reshape(data, (1, nChannels, nHeis))
344 344
345 345 #If the buffer is empty then it takes the data value
346 346 if self.__buffer == None:
347 347 self.__buffer = data
348 348 self.__profIndex += 1
349 349 return
350 350
351 351 #If the buffer length is lower than n then stakcing the data value
352 352 if self.__profIndex < self.n:
353 353 self.__buffer = numpy.vstack((self.__buffer, data))
354 354 self.__profIndex += 1
355 355 return
356 356
357 357 #If the buffer length is equal to n then replacing the last buffer value with the data value
358 358 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
359 359 self.__buffer[self.n-1] = data
360 360 self.__profIndex = self.n
361 361 return
362 362
363 363
364 364 def pushData(self):
365 365 """
366 366 Return the sum of the last profiles and the profiles used in the sum.
367 367
368 368 Affected:
369 369
370 370 self.__profileIndex
371 371
372 372 """
373 373
374 374 if not self.__withOverapping:
375 375 data = self.__buffer
376 376 n = self.__profIndex
377 377
378 378 self.__buffer = 0
379 379 self.__profIndex = 0
380 380
381 381 return data, n
382 382
383 383 #Integration with Overlapping
384 384 data = numpy.sum(self.__buffer, axis=0)
385 385 n = self.__profIndex
386 386
387 387 return data, n
388 388
389 389 def byProfiles(self, data):
390 390
391 391 self.__dataReady = False
392 392 avgdata = None
393 393 n = None
394 394
395 395 self.putData(data)
396 396
397 397 if self.__profIndex == self.n:
398 398
399 399 avgdata, n = self.pushData()
400 400 self.__dataReady = True
401 401
402 402 return avgdata
403 403
404 404 def byTime(self, data, datatime):
405 405
406 406 self.__dataReady = False
407 407 avgdata = None
408 408 n = None
409 409
410 410 self.putData(data)
411 411
412 412 if (datatime - self.__initime) >= self.__integrationtime:
413 413 avgdata, n = self.pushData()
414 414 self.n = n
415 415 self.__dataReady = True
416 416
417 417 return avgdata
418 418
419 419 def integrate(self, data, datatime=None):
420 420
421 421 if self.__initime == None:
422 422 self.__initime = datatime
423 423
424 424 if self.__byTime:
425 425 avgdata = self.byTime(data, datatime)
426 426 else:
427 427 avgdata = self.byProfiles(data)
428 428
429 429
430 430 self.__lastdatatime = datatime
431 431
432 432 if avgdata == None:
433 433 return None, None
434 434
435 435 avgdatatime = self.__initime
436 436
437 437 deltatime = datatime -self.__lastdatatime
438 438
439 439 if not self.__withOverapping:
440 440 self.__initime = datatime
441 441 else:
442 442 self.__initime += deltatime
443 443
444 444 return avgdata, avgdatatime
445 445
446 446 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
447 447
448 448 if not self.__isConfig:
449 449 self.setup(n, timeInterval, overlapping)
450 450 self.__isConfig = True
451 451
452 452 avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
453 453
454 454 # dataOut.timeInterval *= n
455 455 dataOut.flagNoData = True
456 456
457 457 if self.__dataReady:
458 458 dataOut.data = avgdata
459 459 dataOut.nCohInt *= self.n
460 460 dataOut.utctime = avgdatatime
461 461 dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
462 462 dataOut.flagNoData = False
463 463
464 464
465 465 class SpectraProc(ProcessingUnit):
466 466
467 467 def __init__(self):
468 468
469 469 self.objectDict = {}
470 470 self.buffer = None
471 471 self.firstdatatime = None
472 472 self.profIndex = 0
473 473 self.dataOut = Spectra()
474 474
475 475 def __updateObjFromInput(self):
476 476
477 477 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
478 478 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
479 479 self.dataOut.channelList = self.dataIn.channelList
480 480 self.dataOut.heightList = self.dataIn.heightList
481 481 self.dataOut.dtype = self.dataIn.dtype
482 482 # self.dataOut.nHeights = self.dataIn.nHeights
483 483 # self.dataOut.nChannels = self.dataIn.nChannels
484 484 self.dataOut.nBaud = self.dataIn.nBaud
485 485 self.dataOut.nCode = self.dataIn.nCode
486 486 self.dataOut.code = self.dataIn.code
487 487 self.dataOut.nProfiles = self.dataOut.nFFTPoints
488 488 # self.dataOut.channelIndexList = self.dataIn.channelIndexList
489 489 self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
490 490 self.dataOut.utctime = self.firstdatatime
491 491 self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
492 492 self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
493 493 self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
494 494 self.dataOut.nCohInt = self.dataIn.nCohInt
495 495 self.dataOut.nIncohInt = 1
496 496 self.dataOut.ippSeconds = self.dataIn.ippSeconds
497 self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints**self.dataOut.nConInt**self.dataOut.nIncohInt
497 self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nConInt*self.dataOut.nIncohInt
498 498
499 499 def __getFft(self):
500 500 """
501 501 Convierte valores de Voltaje a Spectra
502 502
503 503 Affected:
504 504 self.dataOut.data_spc
505 505 self.dataOut.data_cspc
506 506 self.dataOut.data_dc
507 507 self.dataOut.heightList
508 508 self.dataOut.m_BasicHeader
509 509 self.dataOut.m_ProcessingHeader
510 510 self.dataOut.radarControllerHeaderObj
511 511 self.dataOut.systemHeaderObj
512 512 self.profIndex
513 513 self.buffer
514 514 self.dataOut.flagNoData
515 515 self.dataOut.dtype
516 516 self.dataOut.nPairs
517 517 self.dataOut.nChannels
518 518 self.dataOut.nProfiles
519 519 self.dataOut.systemHeaderObj.numChannels
520 520 self.dataOut.m_ProcessingHeader.totalSpectra
521 521 self.dataOut.m_ProcessingHeader.profilesPerBlock
522 522 self.dataOut.m_ProcessingHeader.numHeights
523 523 self.dataOut.m_ProcessingHeader.spectraComb
524 524 self.dataOut.m_ProcessingHeader.shif_fft
525 525 """
526 526 fft_volt = numpy.fft.fft(self.buffer,axis=1)
527 527 dc = fft_volt[:,0,:]
528 528
529 529 #calculo de self-spectra
530 530 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
531 531 spc = fft_volt * numpy.conjugate(fft_volt)
532 532 spc = spc.real
533 533
534 534 blocksize = 0
535 535 blocksize += dc.size
536 536 blocksize += spc.size
537 537
538 538 cspc = None
539 539 pairIndex = 0
540 540 if self.dataOut.pairsList != None:
541 541 #calculo de cross-spectra
542 542 cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
543 543 for pair in self.dataOut.pairsList:
544 544 cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
545 545 pairIndex += 1
546 546 blocksize += cspc.size
547 547
548 548 self.dataOut.data_spc = spc
549 549 self.dataOut.data_cspc = cspc
550 550 self.dataOut.data_dc = dc
551 551 self.dataOut.blockSize = blocksize
552 552
553 553 def init(self, nFFTPoints=None, pairsList=None):
554 554
555 555 if self.dataIn.type == "Spectra":
556 556 self.dataOut.copy(self.dataIn)
557 557 return
558 558
559 559 if self.dataIn.type == "Voltage":
560 560
561 561 if nFFTPoints == None:
562 raise ValueError, "This SpectraProc.setup() need nFFTPoints input variable"
562 raise ValueError, "This SpectraProc.init() need nFFTPoints input variable"
563 563
564 564 if pairsList == None:
565 565 nPairs = 0
566 566 else:
567 567 nPairs = len(pairsList)
568 568
569 569 self.dataOut.nFFTPoints = nFFTPoints
570 570 self.dataOut.pairsList = pairsList
571 571 self.dataOut.nPairs = nPairs
572 572
573 573 if self.buffer == None:
574 574 self.buffer = numpy.zeros((self.dataIn.nChannels,
575 575 self.dataOut.nFFTPoints,
576 576 self.dataIn.nHeights),
577 577 dtype='complex')
578 578
579 579
580 580 self.buffer[:,self.profIndex,:] = self.dataIn.data
581 581 self.profIndex += 1
582 582
583 583 if self.firstdatatime == None:
584 584 self.firstdatatime = self.dataIn.utctime
585 585
586 586 if self.profIndex == self.dataOut.nFFTPoints:
587 587 self.__updateObjFromInput()
588 588 self.__getFft()
589 589
590 590 self.dataOut.flagNoData = False
591 591
592 592 self.buffer = None
593 593 self.firstdatatime = None
594 594 self.profIndex = 0
595 595
596 596 return
597 597
598 598 raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
599 599
600 600 def selectChannels(self, channelList):
601 601
602 602 channelIndexList = []
603 603
604 604 for channel in channelList:
605 605 index = self.dataOut.channelList.index(channel)
606 606 channelIndexList.append(index)
607 607
608 608 self.selectChannelsByIndex(channelIndexList)
609 609
610 610 def selectChannelsByIndex(self, channelIndexList):
611 611 """
612 612 Selecciona un bloque de datos en base a canales segun el channelIndexList
613 613
614 614 Input:
615 615 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
616 616
617 617 Affected:
618 618 self.dataOut.data_spc
619 619 self.dataOut.channelIndexList
620 620 self.dataOut.nChannels
621 621
622 622 Return:
623 623 None
624 624 """
625 625
626 626 for channelIndex in channelIndexList:
627 627 if channelIndex not in self.dataOut.channelIndexList:
628 628 print channelIndexList
629 629 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
630 630
631 631 nChannels = len(channelIndexList)
632 632
633 633 data_spc = self.dataOut.data_spc[channelIndexList,:]
634 634
635 635 self.dataOut.data_spc = data_spc
636 636 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
637 637 # self.dataOut.nChannels = nChannels
638 638
639 639 return 1
640 640
641 641
642 642 class IncohInt(Operation):
643 643
644 644
645 645 __profIndex = 0
646 646 __withOverapping = False
647 647
648 648 __byTime = False
649 649 __initime = None
650 650 __lastdatatime = None
651 651 __integrationtime = None
652 652
653 653 __buffer_spc = None
654 654 __buffer_cspc = None
655 655 __buffer_dc = None
656 656
657 657 __dataReady = False
658 658
659 659 n = None
660 660
661 661
662 662 def __init__(self):
663 663
664 664 self.__isConfig = False
665 665
666 666 def setup(self, n=None, timeInterval=None, overlapping=False):
667 667 """
668 668 Set the parameters of the integration class.
669 669
670 670 Inputs:
671 671
672 672 n : Number of coherent integrations
673 673 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
674 674 overlapping :
675 675
676 676 """
677 677
678 678 self.__initime = None
679 679 self.__lastdatatime = 0
680 680 self.__buffer_spc = None
681 681 self.__buffer_cspc = None
682 682 self.__buffer_dc = None
683 683 self.__dataReady = False
684 684
685 685
686 686 if n == None and timeInterval == None:
687 687 raise ValueError, "n or timeInterval should be specified ..."
688 688
689 689 if n != None:
690 690 self.n = n
691 691 self.__byTime = False
692 692 else:
693 693 self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
694 694 self.n = 9999
695 695 self.__byTime = True
696 696
697 697 if overlapping:
698 698 self.__withOverapping = True
699 699 else:
700 700 self.__withOverapping = False
701 701 self.__buffer_spc = 0
702 702 self.__buffer_cspc = 0
703 703 self.__buffer_dc = 0
704 704
705 705 self.__profIndex = 0
706 706
707 707 def putData(self, data_spc, data_cspc, data_dc):
708 708
709 709 """
710 710 Add a profile to the __buffer_spc and increase in one the __profileIndex
711 711
712 712 """
713 713
714 714 if not self.__withOverapping:
715 715 self.__buffer_spc += data_spc
716 716
717 717 if data_cspc == None:
718 718 self.__buffer_cspc = None
719 719 else:
720 720 self.__buffer_cspc += data_cspc
721 721
722 722 if data_dc == None:
723 723 self.__buffer_dc = None
724 724 else:
725 725 self.__buffer_dc += data_dc
726 726
727 727 self.__profIndex += 1
728 728 return
729 729
730 730 #Overlapping data
731 731 nChannels, nFFTPoints, nHeis = data_spc.shape
732 732 data_spc = numpy.reshape(data_spc, (1, nChannels, nFFTPoints, nHeis))
733 733 data_cspc = numpy.reshape(data_cspc, (1, -1, nFFTPoints, nHeis))
734 734 data_dc = numpy.reshape(data_dc, (1, -1, nHeis))
735 735
736 736 #If the buffer is empty then it takes the data value
737 737 if self.__buffer_spc == None:
738 738 self.__buffer_spc = data_spc.copy()
739 739
740 740 if data_cspc == None:
741 741 self.__buffer_cspc = None
742 742 else:
743 743 self.__buffer_cspc += data_cspc.copy()
744 744
745 745 if data_dc == None:
746 746 self.__buffer_dc = None
747 747 else:
748 748 self.__buffer_dc += data_dc.copy()
749 749
750 750 self.__profIndex += 1
751 751 return
752 752
753 753 #If the buffer length is lower than n then stakcing the data value
754 754 if self.__profIndex < self.n:
755 755 self.__buffer_spc = numpy.vstack((self.__buffer_spc, data_spc))
756 756
757 757 if self.__buffer_cspc != None:
758 758 self.__buffer_cspc = numpy.vstack((self.__buffer_cspc, data_cspc))
759 759
760 760 if self.__buffer_dc != None:
761 761 self.__buffer_dc = numpy.vstack((self.__buffer_dc, data_dc))
762 762
763 763 self.__profIndex += 1
764 764 return
765 765
766 766 #If the buffer length is equal to n then replacing the last buffer value with the data value
767 767 self.__buffer_spc = numpy.roll(self.__buffer_spc, -1, axis=0)
768 768 self.__buffer_spc[self.n-1] = data_spc
769 769
770 770 self.__buffer_cspc = numpy.roll(self.__buffer_cspc, -1, axis=0)
771 771 self.__buffer_cspc[self.n-1] = data_cspc
772 772
773 773 self.__buffer_dc = numpy.roll(self.__buffer_dc, -1, axis=0)
774 774 self.__buffer_dc[self.n-1] = data_dc
775 775
776 776 self.__profIndex = self.n
777 777 return
778 778
779 779
780 780 def pushData(self):
781 781 """
782 782 Return the sum of the last profiles and the profiles used in the sum.
783 783
784 784 Affected:
785 785
786 786 self.__profileIndex
787 787
788 788 """
789 789 data_spc = None
790 790 data_cspc = None
791 791 data_dc = None
792 792
793 793 if not self.__withOverapping:
794 794 data_spc = self.__buffer_spc
795 795 data_cspc = self.__buffer_cspc
796 796 data_dc = self.__buffer_dc
797 797
798 798 n = self.__profIndex
799 799
800 800 self.__buffer_spc = 0
801 801 self.__buffer_cspc = 0
802 802 self.__buffer_dc = 0
803 803 self.__profIndex = 0
804 804
805 805 return data_spc, data_cspc, data_dc, n
806 806
807 807 #Integration with Overlapping
808 808 data_spc = numpy.sum(self.__buffer_spc, axis=0)
809 809
810 810 if self.__buffer_cspc != None:
811 811 data_cspc = numpy.sum(self.__buffer_cspc, axis=0)
812 812
813 813 if self.__buffer_dc != None:
814 814 data_dc = numpy.sum(self.__buffer_dc, axis=0)
815 815
816 816 n = self.__profIndex
817 817
818 818 return data_spc, data_cspc, data_dc, n
819 819
820 820 def byProfiles(self, *args):
821 821
822 822 self.__dataReady = False
823 823 avgdata_spc = None
824 824 avgdata_cspc = None
825 825 avgdata_dc = None
826 826 n = None
827 827
828 828 self.putData(*args)
829 829
830 830 if self.__profIndex == self.n:
831 831
832 832 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
833 833 self.__dataReady = True
834 834
835 835 return avgdata_spc, avgdata_cspc, avgdata_dc
836 836
837 837 def byTime(self, datatime, *args):
838 838
839 839 self.__dataReady = False
840 840 avgdata_spc = None
841 841 avgdata_cspc = None
842 842 avgdata_dc = None
843 843 n = None
844 844
845 845 self.putData(*args)
846 846
847 847 if (datatime - self.__initime) >= self.__integrationtime:
848 848 avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
849 849 self.n = n
850 850 self.__dataReady = True
851 851
852 852 return avgdata_spc, avgdata_cspc, avgdata_dc
853 853
854 854 def integrate(self, datatime, *args):
855 855
856 856 if self.__initime == None:
857 857 self.__initime = datatime
858 858
859 859 if self.__byTime:
860 860 avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
861 861 else:
862 862 avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
863 863
864 864 self.__lastdatatime = datatime
865 865
866 866 if avgdata_spc == None:
867 867 return None, None, None, None
868 868
869 869 avgdatatime = self.__initime
870 870
871 871 deltatime = datatime -self.__lastdatatime
872 872
873 873 if not self.__withOverapping:
874 874 self.__initime = datatime
875 875 else:
876 876 self.__initime += deltatime
877 877
878 878 return avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc
879 879
880 880 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
881 881
882 882 if not self.__isConfig:
883 883 self.setup(n, timeInterval, overlapping)
884 884 self.__isConfig = True
885 885
886 886 avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
887 887 dataOut.data_spc,
888 888 dataOut.data_cspc,
889 889 dataOut.data_dc)
890 890
891 891 # dataOut.timeInterval *= n
892 892 dataOut.flagNoData = True
893 893
894 894 if self.__dataReady:
895 895 dataOut.data_spc = avgdata_spc
896 896 dataOut.data_cspc = avgdata_cspc
897 897 dataOut.data_dc = avgdata_dc
898 898
899 899 dataOut.nIncohInt *= self.n
900 900 dataOut.utctime = avgdatatime
901 901 dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints
902 902 dataOut.flagNoData = False
903 903 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now