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