##// END OF EJS Templates
schain
RSS
voltage
José Chávez -
r1061:62f12797e147
parent child
Show More
Side by Side Unified
Context file:
r1061:62f12797e147 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,738 +1,737
1 1 '''
2 2 Created on Jul 2, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 6
7 7 import numpy
8 8
9 9 from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
10 10 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
11 11 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
12 12 from schainpy.model.data.jrodata import Voltage
13 import zmq
14 import tempfile
15 from StringIO import StringIO
13 16 # from _sha import blocksize
14 17
15 18 class VoltageReader(JRODataReader, ProcessingUnit):
16 19 """
17 20 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
18 21 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
19 22 perfiles*alturas*canales) son almacenados en la variable "buffer".
20 23
21 24 perfiles * alturas * canales
22 25
23 26 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
24 27 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
25 28 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
26 29 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
27 30
28 31 Example:
29 32
30 33 dpath = "/home/myuser/data"
31 34
32 35 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
33 36
34 37 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
35 38
36 39 readerObj = VoltageReader()
37 40
38 41 readerObj.setup(dpath, startTime, endTime)
39 42
40 43 while(True):
41 44
42 45 #to get one profile
43 46 profile = readerObj.getData()
44 47
45 48 #print the profile
46 49 print profile
47 50
48 51 #If you want to see all datablock
49 52 print readerObj.datablock
50 53
51 54 if readerObj.flagNoMoreFiles:
52 55 break
53 56
54 57 """
55 58
56 59 ext = ".r"
57 60
58 61 optchar = "D"
59 62 dataOut = None
60 63
61 def __init__(self):
64 def __init__(self, **kwargs):
62 65 """
63 66 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
64 67
65 68 Input:
66 69 dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para
67 70 almacenar un perfil de datos cada vez que se haga un requerimiento
68 71 (getData). El perfil sera obtenido a partir del buffer de datos,
69 72 si el buffer esta vacio se hara un nuevo proceso de lectura de un
70 73 bloque de datos.
71 74 Si este parametro no es pasado se creara uno internamente.
72 75
73 76 Variables afectadas:
74 77 self.dataOut
75 78
76 79 Return:
77 80 None
78 81 """
79 82
80 ProcessingUnit.__init__(self)
83 ProcessingUnit.__init__(self, **kwargs)
81 84
82 85 self.isConfig = False
83 86
84 87 self.datablock = None
85 88
86 89 self.utc = 0
87 90
88 91 self.ext = ".r"
89 92
90 93 self.optchar = "D"
91 94
92 95 self.basicHeaderObj = BasicHeader(LOCALTIME)
93 96
94 97 self.systemHeaderObj = SystemHeader()
95 98
96 99 self.radarControllerHeaderObj = RadarControllerHeader()
97 100
98 101 self.processingHeaderObj = ProcessingHeader()
99 102
100 103 self.online = 0
101 104
102 105 self.fp = None
103 106
104 107 self.idFile = None
105 108
106 109 self.dtype = None
107 110
108 111 self.fileSizeByHeader = None
109 112
110 113 self.filenameList = []
111 114
112 115 self.filename = None
113 116
114 117 self.fileSize = None
115 118
116 119 self.firstHeaderSize = 0
117 120
118 121 self.basicHeaderSize = 24
119 122
120 123 self.pathList = []
121 124
122 125 self.filenameList = []
123 126
124 127 self.lastUTTime = 0
125 128
126 129 self.maxTimeStep = 30
127 130
128 131 self.flagNoMoreFiles = 0
129 132
130 133 self.set = 0
131 134
132 135 self.path = None
133 136
134 137 self.profileIndex = 2**32-1
135 138
136 139 self.delay = 3 #seconds
137 140
138 141 self.nTries = 3 #quantity tries
139 142
140 143 self.nFiles = 3 #number of files for searching
141 144
142 145 self.nReadBlocks = 0
143 146
144 147 self.flagIsNewFile = 1
145 148
146 149 self.__isFirstTimeOnline = 1
147 150
148 151 # self.ippSeconds = 0
149 152
150 153 self.flagDiscontinuousBlock = 0
151 154
152 155 self.flagIsNewBlock = 0
153 156
154 157 self.nTotalBlocks = 0
155 158
156 159 self.blocksize = 0
157 160
158 161 self.dataOut = self.createObjByDefault()
159 162
160 163 self.nTxs = 1
161 164
162 165 self.txIndex = 0
163 166
164 167 def createObjByDefault(self):
165 168
166 169 dataObj = Voltage()
167 170
168 171 return dataObj
169 172
170 173 def __hasNotDataInBuffer(self):
171 174
172 175 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock*self.nTxs:
173 176 return 1
174 177
175 178 return 0
176 179
177 180
178 181 def getBlockDimension(self):
179 182 """
180 183 Obtiene la cantidad de puntos a leer por cada bloque de datos
181 184
182 185 Affected:
183 186 self.blocksize
184 187
185 188 Return:
186 189 None
187 190 """
188 191 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
189 192 self.blocksize = pts2read
190 193
191 194
195
192 196 def readBlock(self):
193 197 """
194 198 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
195 199 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
196 200 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
197 201 es seteado a 0
198 202
199 203 Inputs:
200 204 None
201 205
202 206 Return:
203 207 None
204 208
205 209 Affected:
206 210 self.profileIndex
207 211 self.datablock
208 212 self.flagIsNewFile
209 213 self.flagIsNewBlock
210 214 self.nTotalBlocks
211 215
212 216 Exceptions:
213 217 Si un bloque leido no es un bloque valido
214 218 """
215 219
216 220 # if self.server is not None:
217 221 # self.zBlock = self.receiver.recv()
218 222 # self.zHeader = self.zBlock[:24]
219 223 # self.zDataBlock = self.zBlock[24:]
220 224 # junk = numpy.fromstring(self.zDataBlock, numpy.dtype([('real','<i4'),('imag','<i4')]))
221 225 # self.processingHeaderObj.profilesPerBlock = 240
222 226 # self.processingHeaderObj.nHeights = 248
223 227 # self.systemHeaderObj.nChannels
224 228 # else:
225 229 current_pointer_location = self.fp.tell()
226 230 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
227 231
228 232 try:
229 233 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
230 234 except:
231 235 #print "The read block (%3d) has not enough data" %self.nReadBlocks
232 236
233 237 if self.waitDataBlock(pointer_location=current_pointer_location):
234 238 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
235 239 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
236 240 # return 0
237 241
238 242 #Dimensions : nChannels, nProfiles, nSamples
239 243
240 244 junk = numpy.transpose(junk, (2,0,1))
241 245 self.datablock = junk['real'] + junk['imag']*1j
242 246
243 247 self.profileIndex = 0
244 248
245 249 self.flagIsNewFile = 0
246 250 self.flagIsNewBlock = 1
247 251
248 252 self.nTotalBlocks += 1
249 253 self.nReadBlocks += 1
250 254
251 255 return 1
252 256
253 257 def getFirstHeader(self):
254 258
255 259 self.getBasicHeader()
256 260
257 261 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
258 262
259 263 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
260 264
261 265 if self.nTxs > 1:
262 266 self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
263 267
264 268 #Time interval and code are propierties of dataOut. Its value depends of radarControllerHeaderObj.
265 269
266 270 # self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt
267 271 #
268 272 # if self.radarControllerHeaderObj.code is not None:
269 273 #
270 274 # self.dataOut.nCode = self.radarControllerHeaderObj.nCode
271 275 #
272 276 # self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
273 277 #
274 278 # self.dataOut.code = self.radarControllerHeaderObj.code
275 279
276 280 self.dataOut.dtype = self.dtype
277 281
278 282 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
279 283
280 284 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
281 285
282 286 self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
283 287
284 288 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
285 289
286 290 self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
287 291
288 292 self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data no esta sin flip
289 293
290 294 self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
291 295
292 296 def reshapeData(self):
293 297
294 298 if self.nTxs < 0:
295 299 return
296 300
297 301 if self.nTxs == 1:
298 302 return
299 303
300 304 if self.nTxs < 1 and self.processingHeaderObj.profilesPerBlock % (1./self.nTxs) != 0:
301 305 raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" %(1./self.nTxs, self.processingHeaderObj.profilesPerBlock)
302 306
303 307 if self.nTxs > 1 and self.processingHeaderObj.nHeights % self.nTxs != 0:
304 308 raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" %(self.nTxs, self.processingHeaderObj.nHeights)
305 309
306 310 self.datablock = self.datablock.reshape((self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock*self.nTxs, self.processingHeaderObj.nHeights/self.nTxs))
307 311
308 312 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
309 313 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights/self.nTxs) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
310 314 self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
311 315
312 316 return
313 317
314 318 def readFirstHeaderFromServer(self):
315 319
316 320 self.getFirstHeader()
317 321
318 322 self.firstHeaderSize = self.basicHeaderObj.size
319 323
320 324 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
321 325 if datatype == 0:
322 326 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
323 327 elif datatype == 1:
324 328 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
325 329 elif datatype == 2:
326 330 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
327 331 elif datatype == 3:
328 332 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
329 333 elif datatype == 4:
330 334 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
331 335 elif datatype == 5:
332 336 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
333 337 else:
334 338 raise ValueError, 'Data type was not defined'
335 339
336 340 self.dtype = datatype_str
337 341 #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
338 342 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
339 343 # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
340 344 # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
341 345 self.getBlockDimension()
342 346
343 347
344 348 def getFromServer(self):
345 349 self.flagDiscontinuousBlock = 0
346 350 self.profileIndex = 0
347 351 self.flagIsNewBlock = 1
348 352 self.dataOut.flagNoData = False
349 353 self.nTotalBlocks += 1
350 354 self.nReadBlocks += 1
351 355 self.blockPointer = 0
352 356
353 357 block = self.receiver.recv()
354 358
355 359 self.basicHeaderObj.read(block[self.blockPointer:])
356 360 self.blockPointer += self.basicHeaderObj.length
357 361 self.systemHeaderObj.read(block[self.blockPointer:])
358 362 self.blockPointer += self.systemHeaderObj.length
359 363 self.radarControllerHeaderObj.read(block[self.blockPointer:])
360 364 self.blockPointer += self.radarControllerHeaderObj.length
361 365 self.processingHeaderObj.read(block[self.blockPointer:])
362 366 self.blockPointer += self.processingHeaderObj.length
363 367 self.readFirstHeaderFromServer()
364 368
365 369 timestamp = self.basicHeaderObj.get_datatime()
366 370 print '[Reading] - Block {} - {}'.format(self.nTotalBlocks, timestamp)
367 371 current_pointer_location = self.blockPointer
368 372 junk = numpy.fromstring( block[self.blockPointer:], self.dtype, self.blocksize )
369 373
370 374 try:
371 375 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
372 376 except:
373 377 #print "The read block (%3d) has not enough data" %self.nReadBlocks
374 378 if self.waitDataBlock(pointer_location=current_pointer_location):
375 379 junk = numpy.fromstring( block[self.blockPointer:], self.dtype, self.blocksize )
376 380 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
377 381 # return 0
378 382
379 383 #Dimensions : nChannels, nProfiles, nSamples
380 384
381 385 junk = numpy.transpose(junk, (2,0,1))
382 386 self.datablock = junk['real'] + junk['imag'] * 1j
383 387 self.profileIndex = 0
384 388 if self.selBlocksize == None: self.selBlocksize = self.dataOut.nProfiles
385 389 if self.selBlocktime != None:
386 390 if self.dataOut.nCohInt is not None:
387 391 nCohInt = self.dataOut.nCohInt
388 392 else:
389 393 nCohInt = 1
390 394 self.selBlocksize = int(self.dataOut.nProfiles*round(self.selBlocktime/(nCohInt*self.dataOut.ippSeconds*self.dataOut.nProfiles)))
391 395 self.dataOut.data = self.datablock[:,self.profileIndex:self.profileIndex+self.selBlocksize,:]
392 396 datasize = self.dataOut.data.shape[1]
393 397 if datasize < self.selBlocksize:
394 398 buffer = numpy.zeros((self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype = 'complex')
395 399 buffer[:,:datasize,:] = self.dataOut.data
396 400 self.dataOut.data = buffer
397 401 self.profileIndex = blockIndex
398 402
399 403 self.dataOut.flagDataAsBlock = True
400 404 self.flagIsNewBlock = 1
401 405 self.dataOut.realtime = self.online
402 406
403 407 return self.dataOut.data
404 408
405 409 def getData(self):
406 410 """
407 411 getData obtiene una unidad de datos del buffer de lectura, un perfil, y la copia al objeto self.dataOut
408 412 del tipo "Voltage" con todos los parametros asociados a este (metadata). cuando no hay datos
409 413 en el buffer de lectura es necesario hacer una nueva lectura de los bloques de datos usando
410 414 "readNextBlock"
411 415
412 416 Ademas incrementa el contador del buffer "self.profileIndex" en 1.
413 417
414 418 Return:
415 419
416 420 Si el flag self.getByBlock ha sido seteado el bloque completo es copiado a self.dataOut y el self.profileIndex
417 421 es igual al total de perfiles leidos desde el archivo.
418 422
419 423 Si self.getByBlock == False:
420 424
421 425 self.dataOut.data = buffer[:, thisProfile, :]
422 426
423 427 shape = [nChannels, nHeis]
424 428
425 429 Si self.getByBlock == True:
426 430
427 431 self.dataOut.data = buffer[:, :, :]
428 432
429 433 shape = [nChannels, nProfiles, nHeis]
430 434
431 435 Variables afectadas:
432 436 self.dataOut
433 437 self.profileIndex
434 438
435 439 Affected:
436 440 self.dataOut
437 441 self.profileIndex
438 442 self.flagDiscontinuousBlock
439 443 self.flagIsNewBlock
440 444 """
441
442 445 if self.flagNoMoreFiles:
443 446 self.dataOut.flagNoData = True
444 447 print 'Process finished'
445 448 return 0
446
447 449 self.flagDiscontinuousBlock = 0
448 450 self.flagIsNewBlock = 0
449
450 451 if self.__hasNotDataInBuffer():
451
452 452 if not( self.readNextBlock() ):
453 453 return 0
454 454
455 455 self.getFirstHeader()
456 456
457 457 self.reshapeData()
458
459 458 if self.datablock is None:
460 459 self.dataOut.flagNoData = True
461 460 return 0
462 461
463 462 if not self.getByBlock:
464 463
465 464 """
466 465 Return profile by profile
467 466
468 467 If nTxs > 1 then one profile is divided by nTxs and number of total
469 468 blocks is increased by nTxs (nProfiles *= nTxs)
470 469 """
471 470 self.dataOut.flagDataAsBlock = False
472 471 self.dataOut.data = self.datablock[:,self.profileIndex,:]
473 472 self.dataOut.profileIndex = self.profileIndex
474 473
475 474 self.profileIndex += 1
476 475
477 476 # elif self.selBlocksize==None or self.selBlocksize==self.dataOut.nProfiles:
478 477 # """
479 478 # Return all block
480 479 # """
481 480 # self.dataOut.flagDataAsBlock = True
482 481 # self.dataOut.data = self.datablock
483 482 # self.dataOut.profileIndex = self.dataOut.nProfiles - 1
484 483 #
485 484 # self.profileIndex = self.dataOut.nProfiles
486 485
487 486 else:
488 487 """
489 488 Return a block
490 489 """
491 490 if self.selBlocksize == None: self.selBlocksize = self.dataOut.nProfiles
492 491 if self.selBlocktime != None:
493 492 if self.dataOut.nCohInt is not None:
494 493 nCohInt = self.dataOut.nCohInt
495 494 else:
496 495 nCohInt = 1
497 496 self.selBlocksize = int(self.dataOut.nProfiles*round(self.selBlocktime/(nCohInt*self.dataOut.ippSeconds*self.dataOut.nProfiles)))
498 497
499 498 self.dataOut.data = self.datablock[:,self.profileIndex:self.profileIndex+self.selBlocksize,:]
500 499 self.profileIndex += self.selBlocksize
501 500 datasize = self.dataOut.data.shape[1]
502 501
503 502 if datasize < self.selBlocksize:
504 503 buffer = numpy.zeros((self.dataOut.data.shape[0],self.selBlocksize,self.dataOut.data.shape[2]), dtype = 'complex')
505 504 buffer[:,:datasize,:] = self.dataOut.data
506 505
507 506 while datasize < self.selBlocksize: #Not enough profiles to fill the block
508 507 if not( self.readNextBlock() ):
509 508 return 0
510 509 self.getFirstHeader()
511 510 self.reshapeData()
512 511 if self.datablock is None:
513 512 self.dataOut.flagNoData = True
514 513 return 0
515 514 #stack data
516 515 blockIndex = self.selBlocksize - datasize
517 516 datablock1 = self.datablock[:,:blockIndex,:]
518 517
519 518 buffer[:,datasize:datasize+datablock1.shape[1],:] = datablock1
520 519 datasize += datablock1.shape[1]
521 520
522 521 self.dataOut.data = buffer
523 522 self.profileIndex = blockIndex
524 523
525 524 self.dataOut.flagDataAsBlock = True
526 525 self.dataOut.nProfiles = self.dataOut.data.shape[1]
527 526
528 527 self.dataOut.flagNoData = False
529 528
530 529 self.getBasicHeader()
531 530
532 531 self.dataOut.realtime = self.online
533 532
534 533 return self.dataOut.data
535 534
536 535 class VoltageWriter(JRODataWriter, Operation):
537 536 """
538 537 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
539 538 de los datos siempre se realiza por bloques.
540 539 """
541 540
542 541 ext = ".r"
543 542
544 543 optchar = "D"
545 544
546 545 shapeBuffer = None
547 546
548 547
549 def __init__(self):
548 def __init__(self, **kwargs):
550 549 """
551 550 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
552 551
553 552 Affected:
554 553 self.dataOut
555 554
556 555 Return: None
557 556 """
558 Operation.__init__(self)
557 Operation.__init__(self, **kwargs)
559 558
560 559 self.nTotalBlocks = 0
561 560
562 561 self.profileIndex = 0
563 562
564 563 self.isConfig = False
565 564
566 565 self.fp = None
567 566
568 567 self.flagIsNewFile = 1
569 568
570 569 self.blockIndex = 0
571 570
572 571 self.flagIsNewBlock = 0
573 572
574 573 self.setFile = None
575 574
576 575 self.dtype = None
577 576
578 577 self.path = None
579 578
580 579 self.filename = None
581 580
582 581 self.basicHeaderObj = BasicHeader(LOCALTIME)
583 582
584 583 self.systemHeaderObj = SystemHeader()
585 584
586 585 self.radarControllerHeaderObj = RadarControllerHeader()
587 586
588 587 self.processingHeaderObj = ProcessingHeader()
589 588
590 589 def hasAllDataInBuffer(self):
591 590 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
592 591 return 1
593 592 return 0
594 593
595 594
596 595 def setBlockDimension(self):
597 596 """
598 597 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
599 598
600 599 Affected:
601 600 self.shape_spc_Buffer
602 601 self.shape_cspc_Buffer
603 602 self.shape_dc_Buffer
604 603
605 604 Return: None
606 605 """
607 606 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
608 607 self.processingHeaderObj.nHeights,
609 608 self.systemHeaderObj.nChannels)
610 609
611 610 self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
612 611 self.processingHeaderObj.profilesPerBlock,
613 612 self.processingHeaderObj.nHeights),
614 613 dtype=numpy.dtype('complex64'))
615 614
616 615 def writeBlock(self):
617 616 """
618 617 Escribe el buffer en el file designado
619 618
620 619 Affected:
621 620 self.profileIndex
622 621 self.flagIsNewFile
623 622 self.flagIsNewBlock
624 623 self.nTotalBlocks
625 624 self.blockIndex
626 625
627 626 Return: None
628 627 """
629 628 data = numpy.zeros( self.shapeBuffer, self.dtype )
630 629
631 630 junk = numpy.transpose(self.datablock, (1,2,0))
632 631
633 632 data['real'] = junk.real
634 633 data['imag'] = junk.imag
635 634
636 635 data = data.reshape( (-1) )
637 636
638 637 data.tofile( self.fp )
639 638
640 639 self.datablock.fill(0)
641 640
642 641 self.profileIndex = 0
643 642 self.flagIsNewFile = 0
644 643 self.flagIsNewBlock = 1
645 644
646 645 self.blockIndex += 1
647 646 self.nTotalBlocks += 1
648 647
649 648 # print "[Writing] Block = %04d" %self.blockIndex
650 649
651 650 def putData(self):
652 651 """
653 652 Setea un bloque de datos y luego los escribe en un file
654 653
655 654 Affected:
656 655 self.flagIsNewBlock
657 656 self.profileIndex
658 657
659 658 Return:
660 659 0 : Si no hay data o no hay mas files que puedan escribirse
661 660 1 : Si se escribio la data de un bloque en un file
662 661 """
663 662 if self.dataOut.flagNoData:
664 663 return 0
665 664
666 665 self.flagIsNewBlock = 0
667 666
668 667 if self.dataOut.flagDiscontinuousBlock:
669 668 self.datablock.fill(0)
670 669 self.profileIndex = 0
671 670 self.setNextFile()
672 671
673 672 if self.profileIndex == 0:
674 673 self.setBasicHeader()
675 674
676 675 self.datablock[:,self.profileIndex,:] = self.dataOut.data
677 676
678 677 self.profileIndex += 1
679 678
680 679 if self.hasAllDataInBuffer():
681 680 #if self.flagIsNewFile:
682 681 self.writeNextBlock()
683 682 # self.setFirstHeader()
684 683
685 684 return 1
686 685
687 686 def __getBlockSize(self):
688 687 '''
689 688 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
690 689 '''
691 690
692 691 dtype_width = self.getDtypeWidth()
693 692
694 693 blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.profilesPerBlock * dtype_width * 2)
695 694
696 695 return blocksize
697 696
698 697 def setFirstHeader(self):
699 698
700 699 """
701 700 Obtiene una copia del First Header
702 701
703 702 Affected:
704 703 self.systemHeaderObj
705 704 self.radarControllerHeaderObj
706 705 self.dtype
707 706
708 707 Return:
709 708 None
710 709 """
711 710
712 711 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
713 712 self.systemHeaderObj.nChannels = self.dataOut.nChannels
714 713 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
715 714
716 715 self.processingHeaderObj.dtype = 0 # Voltage
717 716 self.processingHeaderObj.blockSize = self.__getBlockSize()
718 717 self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
719 718 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
720 719 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
721 720 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
722 721 self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
723 722 self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
724 723
725 724 if self.dataOut.code is not None:
726 725 self.processingHeaderObj.code = self.dataOut.code
727 726 self.processingHeaderObj.nCode = self.dataOut.nCode
728 727 self.processingHeaderObj.nBaud = self.dataOut.nBaud
729 728
730 729 if self.processingHeaderObj.nWindows != 0:
731 730 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
732 731 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
733 732 self.processingHeaderObj.nHeights = self.dataOut.nHeights
734 733 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
735 734
736 735 self.processingHeaderObj.processFlags = self.getProcessFlags()
737 736
738 737 self.setBasicHeader()
General Comments 0
You need to be logged in to leave comments. Login now