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