##// END OF EJS Templates
schain-jc
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
This diff has been collapsed as it changes many lines, (528 lines changed) Show them Hide them
@@ -10,61 +10,58 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 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
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".
20
21 perfiles * alturas * canales
23 22
24 perfiles * alturas * canales
25
26 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
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
45 #to get one profile
41
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
64 def __init__(self, **kwargs):
60
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
@@ -72,116 +69,116 class VoltageReader(JRODataReader, ProcessingUnit):
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
153 self.flagDiscontinuousBlock = 0
154
149
150 self.flagDiscontinuousBlock = 0
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
@@ -191,290 +188,191 class VoltageReader(JRODataReader, ProcessingUnit):
191 188 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
192 189 self.blocksize = pts2read
193 190
194
195
191
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
216 Exceptions:
211
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
265 self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()
266
250
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
286 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
287
269
270 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
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 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights/self.nTxs) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
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
318 return
319
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 301
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
302 return
303
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
@@ -482,9 +380,9 class VoltageReader(JRODataReader, ProcessingUnit):
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
@@ -494,20 +392,20 class VoltageReader(JRODataReader, ProcessingUnit):
494 392 if self.dataOut.nCohInt is not None:
495 393 nCohInt = self.dataOut.nCohInt
496 394 else:
497 nCohInt = 1
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
504 if datasize < self.selBlocksize:
401
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 return 0
408 return 0
511 409 self.getFirstHeader()
512 410 self.reshapeData()
513 411 if self.datablock is None:
@@ -516,76 +414,76 class VoltageReader(JRODataReader, ProcessingUnit):
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 de los datos siempre se realiza por bloques.
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
446
548 447
549
550 def __init__(self, **kwargs):
551 """
448 def __init__(self):
449 """
552 450 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
553
554 Affected:
451
452 Affected:
555 453 self.dataOut
556 454
557 455 Return: None
558 456 """
559 Operation.__init__(self, **kwargs)
560
457 Operation.__init__(self)
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
571 self.blockIndex = 0
572
468
469 self.blockIndex = 0
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):
@@ -608,112 +506,112 class VoltageWriter(JRODataWriter, Operation):
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 self.profileIndex
520 self.profileIndex
623 521 self.flagIsNewFile
624 522 self.flagIsNewBlock
625 523 self.nTotalBlocks
626 self.blockIndex
627
524 self.blockIndex
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
643 self.profileIndex = 0
540
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 Setea un bloque de datos y luego los escribe en un file
655
552 Setea un bloque de datos y luego los escribe en un file
553
656 554 Affected:
657 555 self.flagIsNewBlock
658 556 self.profileIndex
659 557
660 Return:
661 0 : Si no hay data o no hay mas files que puedan escribirse
558 Return:
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 #if self.flagIsNewFile:
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 Return:
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
@@ -722,18 +620,18 class VoltageWriter(JRODataWriter, Operation):
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
739 self.setBasicHeader()
636
637 self.setBasicHeader() No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now