##// END OF EJS Templates
schain
RSS
Fix save spectra
Juan C. Espinoza -
r1225:7663a99dc56e
parent child
Show More
Side by Side Unified
Context file:
r1225:7663a99dc56e Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,678 +1,678
1 1 '''
2 2 Created on Jul 2, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 6 import numpy
7 7
8 8 from schainpy.model.io.jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
9 9 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
10 10 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
11 11 from schainpy.model.data.jrodata import Spectra
12 12 from schainpy.utils import log
13 13
14 14 @MPDecorator
15 15 class SpectraReader(JRODataReader, ProcessingUnit):
16 16 """
17 17 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
18 18 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
19 19 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
20 20
21 21 paresCanalesIguales * alturas * perfiles (Self Spectra)
22 22 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
23 23 canales * alturas (DC Channels)
24 24
25 25 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
26 26 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
27 27 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
28 28 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
29 29
30 30 Example:
31 31 dpath = "/home/myuser/data"
32 32
33 33 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
34 34
35 35 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
36 36
37 37 readerObj = SpectraReader()
38 38
39 39 readerObj.setup(dpath, startTime, endTime)
40 40
41 41 while(True):
42 42
43 43 readerObj.getData()
44 44
45 45 print readerObj.data_spc
46 46
47 47 print readerObj.data_cspc
48 48
49 49 print readerObj.data_dc
50 50
51 51 if readerObj.flagNoMoreFiles:
52 52 break
53 53
54 54 """
55 55
56 56 pts2read_SelfSpectra = 0
57 57
58 58 pts2read_CrossSpectra = 0
59 59
60 60 pts2read_DCchannels = 0
61 61
62 62 ext = ".pdata"
63 63
64 64 optchar = "P"
65 65
66 66 dataOut = None
67 67
68 68 nRdChannels = None
69 69
70 70 nRdPairs = None
71 71
72 72 rdPairList = []
73 73
74 74 def __init__(self):#, **kwargs):
75 75 """
76 76 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
77 77
78 78 Inputs:
79 79 dataOut : Objeto de la clase Spectra. Este objeto sera utilizado para
80 80 almacenar un perfil de datos cada vez que se haga un requerimiento
81 81 (getData). El perfil sera obtenido a partir del buffer de datos,
82 82 si el buffer esta vacio se hara un nuevo proceso de lectura de un
83 83 bloque de datos.
84 84 Si este parametro no es pasado se creara uno internamente.
85 85
86 86 Affected:
87 87 self.dataOut
88 88
89 89 Return : None
90 90 """
91 91
92 92 #Eliminar de la base la herencia
93 93 ProcessingUnit.__init__(self)#, **kwargs)
94 94
95 95 # self.isConfig = False
96 96
97 97 self.pts2read_SelfSpectra = 0
98 98
99 99 self.pts2read_CrossSpectra = 0
100 100
101 101 self.pts2read_DCchannels = 0
102 102
103 103 self.datablock = None
104 104
105 105 self.utc = None
106 106
107 107 self.ext = ".pdata"
108 108
109 109 self.optchar = "P"
110 110
111 111 self.basicHeaderObj = BasicHeader(LOCALTIME)
112 112
113 113 self.systemHeaderObj = SystemHeader()
114 114
115 115 self.radarControllerHeaderObj = RadarControllerHeader()
116 116
117 117 self.processingHeaderObj = ProcessingHeader()
118 118
119 119 self.online = 0
120 120
121 121 self.fp = None
122 122
123 123 self.idFile = None
124 124
125 125 self.dtype = None
126 126
127 127 self.fileSizeByHeader = None
128 128
129 129 self.filenameList = []
130 130
131 131 self.filename = None
132 132
133 133 self.fileSize = None
134 134
135 135 self.firstHeaderSize = 0
136 136
137 137 self.basicHeaderSize = 24
138 138
139 139 self.pathList = []
140 140
141 141 self.lastUTTime = 0
142 142
143 143 self.maxTimeStep = 30
144 144
145 145 self.flagNoMoreFiles = 0
146 146
147 147 self.set = 0
148 148
149 149 self.path = None
150 150
151 151 self.delay = 60 #seconds
152 152
153 153 self.nTries = 3 #quantity tries
154 154
155 155 self.nFiles = 3 #number of files for searching
156 156
157 157 self.nReadBlocks = 0
158 158
159 159 self.flagIsNewFile = 1
160 160
161 161 self.__isFirstTimeOnline = 1
162 162
163 163 # self.ippSeconds = 0
164 164
165 165 self.flagDiscontinuousBlock = 0
166 166
167 167 self.flagIsNewBlock = 0
168 168
169 169 self.nTotalBlocks = 0
170 170
171 171 self.blocksize = 0
172 172
173 173 self.dataOut = self.createObjByDefault()
174 174
175 175 self.profileIndex = 1 #Always
176 176
177 177
178 178 def createObjByDefault(self):
179 179
180 180 dataObj = Spectra()
181 181
182 182 return dataObj
183 183
184 184 def __hasNotDataInBuffer(self):
185 185 return 1
186 186
187 187
188 188 def getBlockDimension(self):
189 189 """
190 190 Obtiene la cantidad de puntos a leer por cada bloque de datos
191 191
192 192 Affected:
193 193 self.nRdChannels
194 194 self.nRdPairs
195 195 self.pts2read_SelfSpectra
196 196 self.pts2read_CrossSpectra
197 197 self.pts2read_DCchannels
198 198 self.blocksize
199 199 self.dataOut.nChannels
200 200 self.dataOut.nPairs
201 201
202 202 Return:
203 203 None
204 204 """
205 205 self.nRdChannels = 0
206 206 self.nRdPairs = 0
207 207 self.rdPairList = []
208 208
209 209 for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
210 210 if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
211 211 self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
212 212 else:
213 213 self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
214 214 self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
215 215
216 216 pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
217 217
218 218 self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
219 219 self.blocksize = self.pts2read_SelfSpectra
220 220
221 221 if self.processingHeaderObj.flag_cspc:
222 222 self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
223 223 self.blocksize += self.pts2read_CrossSpectra
224 224
225 225 if self.processingHeaderObj.flag_dc:
226 226 self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
227 227 self.blocksize += self.pts2read_DCchannels
228 228
229 229 # self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
230 230
231 231
232 232 def readBlock(self):
233 233 """
234 234 Lee el bloque de datos desde la posicion actual del puntero del archivo
235 235 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
236 236 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
237 237 es seteado a 0
238 238
239 239 Return: None
240 240
241 241 Variables afectadas:
242 242
243 243 self.flagIsNewFile
244 244 self.flagIsNewBlock
245 245 self.nTotalBlocks
246 246 self.data_spc
247 247 self.data_cspc
248 248 self.data_dc
249 249
250 250 Exceptions:
251 251 Si un bloque leido no es un bloque valido
252 252 """
253 253 blockOk_flag = False
254 254 fpointer = self.fp.tell()
255 255
256 256 spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
257 257 spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
258 258
259 259 if self.processingHeaderObj.flag_cspc:
260 260 cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
261 261 cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
262 262
263 263 if self.processingHeaderObj.flag_dc:
264 264 dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
265 265 dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
266 266
267 267
268 268 if not self.processingHeaderObj.shif_fft:
269 269 #desplaza a la derecha en el eje 2 determinadas posiciones
270 270 shift = int(self.processingHeaderObj.profilesPerBlock/2)
271 271 spc = numpy.roll( spc, shift , axis=2 )
272 272
273 273 if self.processingHeaderObj.flag_cspc:
274 274 #desplaza a la derecha en el eje 2 determinadas posiciones
275 275 cspc = numpy.roll( cspc, shift, axis=2 )
276 276
277 277 #Dimensions : nChannels, nProfiles, nSamples
278 278 spc = numpy.transpose( spc, (0,2,1) )
279 279 self.data_spc = spc
280 280
281 281 if self.processingHeaderObj.flag_cspc:
282 282 cspc = numpy.transpose( cspc, (0,2,1) )
283 283 self.data_cspc = cspc['real'] + cspc['imag']*1j
284 284 else:
285 285 self.data_cspc = None
286 286
287 287 if self.processingHeaderObj.flag_dc:
288 288 self.data_dc = dc['real'] + dc['imag']*1j
289 289 else:
290 290 self.data_dc = None
291 291
292 292 self.flagIsNewFile = 0
293 293 self.flagIsNewBlock = 1
294 294
295 295 self.nTotalBlocks += 1
296 296 self.nReadBlocks += 1
297 297
298 298 return 1
299 299
300 300 def getFirstHeader(self):
301 301
302 302 self.getBasicHeader()
303 303
304 304 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
305 305
306 306 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
307 307
308 308 # self.dataOut.ippSeconds = self.ippSeconds
309 309
310 310 # self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.processingHeaderObj.profilesPerBlock
311 311
312 312 self.dataOut.dtype = self.dtype
313 313
314 314 # self.dataOut.nPairs = self.nPairs
315 315
316 316 self.dataOut.pairsList = self.rdPairList
317 317
318 318 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
319 319
320 320 self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
321 321
322 322 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
323 323
324 324 self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
325 325
326 326 xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
327 327
328 328 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
329 329
330 330 self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
331 331
332 332 self.dataOut.flagShiftFFT = True #Data is always shifted
333 333
334 334 self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
335 335
336 336 self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data esta sin flip
337 337
338 338 def getData(self):
339 339 """
340 340 First method to execute before "RUN" is called.
341 341
342 342 Copia el buffer de lectura a la clase "Spectra",
343 343 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
344 344 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
345 345
346 346 Return:
347 347 0 : Si no hay mas archivos disponibles
348 348 1 : Si hizo una buena copia del buffer
349 349
350 350 Affected:
351 351 self.dataOut
352 352
353 353 self.flagDiscontinuousBlock
354 354 self.flagIsNewBlock
355 355 """
356 356
357 357 if self.flagNoMoreFiles:
358 358 self.dataOut.flagNoData = True
359 359 print('Process finished')
360 360 return 0
361 361
362 362 self.flagDiscontinuousBlock = 0
363 363 self.flagIsNewBlock = 0
364 364
365 365 if self.__hasNotDataInBuffer():
366 366
367 367 if not( self.readNextBlock() ):
368 368 self.dataOut.flagNoData = True
369 369 return 0
370 370
371 371 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
372 372
373 373 if self.data_spc is None:
374 374 self.dataOut.flagNoData = True
375 375 return 0
376 376
377 377 self.getBasicHeader()
378 378
379 379 self.getFirstHeader()
380 380
381 381 self.dataOut.data_spc = self.data_spc
382 382
383 383 self.dataOut.data_cspc = self.data_cspc
384 384
385 385 self.dataOut.data_dc = self.data_dc
386 386
387 387 self.dataOut.flagNoData = False
388 388
389 389 self.dataOut.realtime = self.online
390 390
391 391 return self.dataOut.data_spc
392 392 @MPDecorator
393 393 class SpectraWriter(JRODataWriter, Operation):
394 394
395 395 """
396 396 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
397 397 de los datos siempre se realiza por bloques.
398 398 """
399 399
400 400 ext = ".pdata"
401 401
402 402 optchar = "P"
403 403
404 404 shape_spc_Buffer = None
405 405
406 406 shape_cspc_Buffer = None
407 407
408 408 shape_dc_Buffer = None
409 409
410 410 data_spc = None
411 411
412 412 data_cspc = None
413 413
414 414 data_dc = None
415 415
416 416 def __init__(self):
417 417 """
418 418 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
419 419
420 420 Affected:
421 421 self.dataOut
422 422 self.basicHeaderObj
423 423 self.systemHeaderObj
424 424 self.radarControllerHeaderObj
425 425 self.processingHeaderObj
426 426
427 427 Return: None
428 428 """
429 429
430 430 Operation.__init__(self)
431 431
432 432 self.nTotalBlocks = 0
433 433
434 434 self.data_spc = None
435 435
436 436 self.data_cspc = None
437 437
438 438 self.data_dc = None
439 439
440 440 self.fp = None
441 441
442 442 self.flagIsNewFile = 1
443 443
444 444 self.nTotalBlocks = 0
445 445
446 446 self.flagIsNewBlock = 0
447 447
448 448 self.setFile = None
449 449
450 450 self.dtype = None
451 451
452 452 self.path = None
453 453
454 454 self.noMoreFiles = 0
455 455
456 456 self.filename = None
457 457
458 458 self.basicHeaderObj = BasicHeader(LOCALTIME)
459 459
460 460 self.systemHeaderObj = SystemHeader()
461 461
462 462 self.radarControllerHeaderObj = RadarControllerHeader()
463 463
464 464 self.processingHeaderObj = ProcessingHeader()
465 465
466 466
467 467 def hasAllDataInBuffer(self):
468 468 return 1
469 469
470 470
471 471 def setBlockDimension(self):
472 472 """
473 473 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
474 474
475 475 Affected:
476 476 self.shape_spc_Buffer
477 477 self.shape_cspc_Buffer
478 478 self.shape_dc_Buffer
479 479
480 480 Return: None
481 481 """
482 482 self.shape_spc_Buffer = (self.dataOut.nChannels,
483 483 self.processingHeaderObj.nHeights,
484 484 self.processingHeaderObj.profilesPerBlock)
485 485
486 486 self.shape_cspc_Buffer = (self.dataOut.nPairs,
487 487 self.processingHeaderObj.nHeights,
488 488 self.processingHeaderObj.profilesPerBlock)
489 489
490 490 self.shape_dc_Buffer = (self.dataOut.nChannels,
491 491 self.processingHeaderObj.nHeights)
492 492
493 493
494 494 def writeBlock(self):
495 495 """processingHeaderObj
496 496 Escribe el buffer en el file designado
497 497
498 498 Affected:
499 499 self.data_spc
500 500 self.data_cspc
501 501 self.data_dc
502 502 self.flagIsNewFile
503 503 self.flagIsNewBlock
504 504 self.nTotalBlocks
505 505 self.nWriteBlocks
506 506
507 507 Return: None
508 508 """
509 509
510 510 spc = numpy.transpose( self.data_spc, (0,2,1) )
511 511 if not self.processingHeaderObj.shif_fft:
512 512 spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
513 513 data = spc.reshape((-1))
514 514 data = data.astype(self.dtype[0])
515 515 data.tofile(self.fp)
516 516
517 517 if self.data_cspc is not None:
518 518
519 519 cspc = numpy.transpose( self.data_cspc, (0,2,1) )
520 #data = numpy.zeros( numpy.shape(cspc), self.dtype )
520 data = numpy.zeros( numpy.shape(cspc), self.dtype )
521 521 #print 'data.shape', self.shape_cspc_Buffer
522 522 if not self.processingHeaderObj.shif_fft:
523 523 cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
524 524 data['real'] = cspc.real
525 525 data['imag'] = cspc.imag
526 526 data = data.reshape((-1))
527 527 data.tofile(self.fp)
528 528
529 529 if self.data_dc is not None:
530 530
531 531 dc = self.data_dc
532 532 data = numpy.zeros( numpy.shape(dc), self.dtype )
533 533 data['real'] = dc.real
534 534 data['imag'] = dc.imag
535 535 data = data.reshape((-1))
536 536 data.tofile(self.fp)
537 537
538 538 # self.data_spc.fill(0)
539 539 #
540 540 # if self.data_dc is not None:
541 541 # self.data_dc.fill(0)
542 542 #
543 543 # if self.data_cspc is not None:
544 544 # self.data_cspc.fill(0)
545 545
546 546 self.flagIsNewFile = 0
547 547 self.flagIsNewBlock = 1
548 548 self.nTotalBlocks += 1
549 549 self.nWriteBlocks += 1
550 550 self.blockIndex += 1
551 551
552 552 # print "[Writing] Block = %d04" %self.blockIndex
553 553
554 554 def putData(self):
555 555 """
556 556 Setea un bloque de datos y luego los escribe en un file
557 557
558 558 Affected:
559 559 self.data_spc
560 560 self.data_cspc
561 561 self.data_dc
562 562
563 563 Return:
564 564 0 : Si no hay data o no hay mas files que puedan escribirse
565 565 1 : Si se escribio la data de un bloque en un file
566 566 """
567 567
568 568 if self.dataOut.flagNoData:
569 569 return 0
570 570
571 571 self.flagIsNewBlock = 0
572 572
573 573 if self.dataOut.flagDiscontinuousBlock:
574 574 self.data_spc.fill(0)
575 575 if self.dataOut.data_cspc is not None:
576 576 self.data_cspc.fill(0)
577 577 if self.dataOut.data_dc is not None:
578 578 self.data_dc.fill(0)
579 579 self.setNextFile()
580 580
581 581 if self.flagIsNewFile == 0:
582 582 self.setBasicHeader()
583 583
584 584 self.data_spc = self.dataOut.data_spc.copy()
585 585
586 586 if self.dataOut.data_cspc is not None:
587 587 self.data_cspc = self.dataOut.data_cspc.copy()
588 588
589 589 if self.dataOut.data_dc is not None:
590 590 self.data_dc = self.dataOut.data_dc.copy()
591 591
592 592 # #self.processingHeaderObj.dataBlocksPerFile)
593 593 if self.hasAllDataInBuffer():
594 594 # self.setFirstHeader()
595 595 self.writeNextBlock()
596 596
597 597 def __getBlockSize(self):
598 598 '''
599 599 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
600 600 '''
601 601
602 602 dtype_width = self.getDtypeWidth()
603 603
604 604 pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
605 605
606 606 pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
607 607 blocksize = (pts2write_SelfSpectra*dtype_width)
608 608
609 609 if self.dataOut.data_cspc is not None:
610 610 pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
611 611 blocksize += (pts2write_CrossSpectra*dtype_width*2)
612 612
613 613 if self.dataOut.data_dc is not None:
614 614 pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
615 615 blocksize += (pts2write_DCchannels*dtype_width*2)
616 616
617 617 # blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
618 618
619 619 return blocksize
620 620
621 621 def setFirstHeader(self):
622 622
623 623 """
624 624 Obtiene una copia del First Header
625 625
626 626 Affected:
627 627 self.systemHeaderObj
628 628 self.radarControllerHeaderObj
629 629 self.dtype
630 630
631 631 Return:
632 632 None
633 633 """
634 634
635 635 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
636 636 self.systemHeaderObj.nChannels = self.dataOut.nChannels
637 637 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
638 638
639 639 self.processingHeaderObj.dtype = 1 # Spectra
640 640 self.processingHeaderObj.blockSize = self.__getBlockSize()
641 641 self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
642 642 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
643 643 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
644 644 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
645 645 self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
646 646 self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
647 647 self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT
648 648
649 649 if self.processingHeaderObj.totalSpectra > 0:
650 650 channelList = []
651 651 for channel in range(self.dataOut.nChannels):
652 652 channelList.append(channel)
653 653 channelList.append(channel)
654 654
655 655 pairsList = []
656 656 if self.dataOut.nPairs > 0:
657 657 for pair in self.dataOut.pairsList:
658 658 pairsList.append(pair[0])
659 659 pairsList.append(pair[1])
660 660
661 661 spectraComb = channelList + pairsList
662 662 spectraComb = numpy.array(spectraComb, dtype="u1")
663 663 self.processingHeaderObj.spectraComb = spectraComb
664 664
665 665 if self.dataOut.code is not None:
666 666 self.processingHeaderObj.code = self.dataOut.code
667 667 self.processingHeaderObj.nCode = self.dataOut.nCode
668 668 self.processingHeaderObj.nBaud = self.dataOut.nBaud
669 669
670 670 if self.processingHeaderObj.nWindows != 0:
671 671 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
672 672 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
673 673 self.processingHeaderObj.nHeights = self.dataOut.nHeights
674 674 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
675 675
676 676 self.processingHeaderObj.processFlags = self.getProcessFlags()
677 677
678 678 self.setBasicHeader() No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now