##// END OF EJS Templates
schain-jc
RSS
Modificaciones realizadas para mejoras en el Modelo, Funciones de Lectura y Escritura de Voltage
Miguel Valdez -
r120:777f5fd367a9
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,48 +1,57
1
1 import os, sys
2 2 import copy
3 3 import numpy
4 from JROHeader import BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
5 4
6 class Data:
7 def __init__(self):
8 pass
5 path = os.path.split(os.getcwd())[0]
6 sys.path.append(path)
9 7
10 def copy(self, inputObj=None):
11 if inputObj == None:
12 return copy.deepcopy(self)
8 from IO.JROHeader import SystemHeader, RadarControllerHeader
13 9
14 for key in inputObj.__dict__.keys():
15 self.__dict__[key] = inputObj.__dict__[key]
10 class JROData():
11
12 # m_BasicHeader = BasicHeader()
13 # m_ProcessingHeader = ProcessingHeader()
16 14
17 def deepcopy(self):
18 return copy.deepcopy(self)
15 systemHeaderObj = SystemHeader()
16
17 radarControllerHeaderObj = RadarControllerHeader()
19 18
20 class JROData(Data):
21 19 data = None
22 # m_BasicHeader = BasicHeader()
23 # m_SystemHeader = SystemHeader()
24 # m_RadarControllerHeader = RadarControllerHeader()
25 # m_ProcessingHeader = ProcessingHeader()
20
26 21 type = None
27 dataType = None
28 heightList = None
29 channelIndexList = None
30 channelList = None
22
23 dtype = None
24
25 nChannels = None
26
31 27 nHeights = None
28
32 29 nProfiles = None
33 nBlocksPerFile = None
34 nChannels = None
30
31 heightList = None
32
33 channelList = None
34
35 channelIndexList = None
36
35 37 flagNoData = False
36 flagResetProcessing = False
38
39 flagTimeBlock = False
40
41 dataUtcTime = None
37 42
38 43 def __init__(self):
44
39 45 raise ValueError, "This class has not been implemented"
40
41 # def updateHeaderFromObj(self):
42 # pass
43 #
44 #
45 # def updateObjFromHeader(self):
46 # pass
47 46
47 def copy(self, inputObj=None):
48
49 if inputObj == None:
50 return copy.deepcopy(self)
51
52 for key in inputObj.__dict__.keys():
53 self.__dict__[key] = inputObj.__dict__[key]
54
55 def deepcopy(self):
48 56
57 return copy.deepcopy(self) No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,27 +1,52
1 import os, sys
1 2 import numpy
3
4 path = os.path.split(os.getcwd())[0]
5 sys.path.append(path)
6
2 7 from JROData import JROData
3 # No deberia importar los Headers
8 from IO.JROHeader import SystemHeader, RadarControllerHeader
9
4 10 class Voltage(JROData):
5 data = None
11
6 12 nCohInt = None
7 13
8 14 def __init__(self):
9 self.type = "Voltage"
10
11 def updateObjFromHeader(self):
12 xi = self.m_ProcessingHeader.firstHeight
13 step = self.m_ProcessingHeader.deltaHeight
14 xf = xi + self.m_ProcessingHeader.numHeights*step
15
16 self.heightList = numpy.arange(xi, xf, step)
17 self.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
18 self.channelList = numpy.arange(self.m_SystemHeader.numChannels)
19
20 self.nHeights = len(self.heightList)
21 self.nChannels = len(self.channelList)
22 self.nProfiles = self.m_ProcessingHeader.profilesPerBlock
23 self.nBlocksPerFile = self.m_ProcessingHeader.dataBlocksPerFile
24 self.nCohInt = self.m_ProcessingHeader.coherentInt
15 '''
16 Constructor
17 '''
18
19 self.m_RadarControllerHeader = RadarControllerHeader()
25 20
26 def updateHeaderFromObj(self):
27 pass No newline at end of file
21 self.m_SystemHeader = SystemHeader()
22
23 self.type = "Voltage"
24
25 #data es un numpy array de 2 dmensiones ( canales, alturas)
26 self.data = None
27
28 self.dtype = None
29
30 self.nChannels = 0
31
32 self.nHeights = 0
33
34 self.nProfiles = None
35
36 self.heightList = None
37
38 self.channelList = None
39
40 self.channelIndexList = None
41
42 self.flagNoData = True
43
44 self.flagTimeBlock = False
45
46 self.dataUtcTime = None
47
48 self.nCohInt = None
49
50
51
52 No newline at end of file
Show file before | Show file after | Hide comments
@@ -8,8 +8,8 import time, datetime
8 8 path = os.path.split(os.getcwd())[0]
9 9 sys.path.append(path)
10 10
11 from Model.JROHeader import *
12 from Model.JROData import JROData
11 from JROHeader import *
12 from Data.JROData import JROData
13 13
14 14 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
15 15 """
@@ -32,21 +32,21 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
32 32 Si la cabecera no puede ser leida.
33 33
34 34 """
35 m_BasicHeader = BasicHeader()
35 basicHeaderObj = BasicHeader()
36 36
37 37 try:
38 38 fp = open(filename,'rb')
39 39 except:
40 40 raise IOError, "The file %s can't be opened" %(filename)
41 41
42 sts = m_BasicHeader.read(fp)
42 sts = basicHeaderObj.read(fp)
43 43 fp.close()
44 44
45 45 if not(sts):
46 46 print "Skipping the file %s because it has not a valid header" %(filename)
47 47 return 0
48 48
49 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds > m_BasicHeader.utc)):
49 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
50 50 return 0
51 51
52 52 return 1
@@ -55,28 +55,59 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
55 55
56 56
57 57 class JRODataIO:
58
58 59 c = 3E8
59 m_BasicHeader = BasicHeader()
60 m_SystemHeader = SystemHeader()
61 m_RadarControllerHeader = RadarControllerHeader()
62 m_ProcessingHeader = ProcessingHeader()
60
61 basicHeaderObj = BasicHeader()
62
63 systemHeaderObj = SystemHeader()
64
65 radarControllerHeaderObj = RadarControllerHeader()
66
67 processingHeaderObj = ProcessingHeader()
68
63 69 online = 0
64 dataType = None
70
71 dtype = None
72
65 73 pathList = []
74
66 75 filenameList = []
76
67 77 filename = None
78
68 79 ext = None
69 fileIndex = None
80
70 81 flagNoMoreFiles = 0
82
71 83 flagIsNewFile = 1
72 flagResetProcessing = 0
84
85 flagTimeBlock = 0
86
73 87 flagIsNewBlock = 0
88
74 89 fp = None
90
75 91 firstHeaderSize = 0
92
76 93 basicHeaderSize = 24
94
95 versionFile = 1103
96
77 97 fileSize = None
98
78 99 ippSeconds = None
100
79 101 fileSizeByHeader = None
102
103 fileIndex = None
104
105 profileIndex = None
106
107 blockIndex = None
108
109 nTotalBlocks = None
110
80 111 def __init__(self):
81 112 pass
82 113
@@ -261,25 +292,25 class JRODataReader(JRODataIO):
261 292 if fp == None:
262 293 fp = self.fp
263 294
264 self.m_ProcessingHeader.read(fp)
295 self.processingHeaderObj.read(fp)
265 296
266 297 def __rdRadarControllerHeader(self, fp=None):
267 298 if fp == None:
268 299 fp = self.fp
269 300
270 self.m_RadarControllerHeader.read(fp)
301 self.radarControllerHeaderObj.read(fp)
271 302
272 303 def __rdSystemHeader(self, fp=None):
273 304 if fp == None:
274 305 fp = self.fp
275 306
276 self.m_SystemHeader.read(fp)
307 self.systemHeaderObj.read(fp)
277 308
278 309 def __rdBasicHeader(self, fp=None):
279 310 if fp == None:
280 311 fp = self.fp
281 312
282 self.m_BasicHeader.read(fp)
313 self.basicHeaderObj.read(fp)
283 314
284 315
285 316 def __readFirstHeader(self):
@@ -288,9 +319,9 class JRODataReader(JRODataIO):
288 319 self.__rdRadarControllerHeader()
289 320 self.__rdProcessingHeader()
290 321
291 self.firstHeaderSize = self.m_BasicHeader.size
322 self.firstHeaderSize = self.basicHeaderObj.size
292 323
293 datatype = int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
324 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
294 325 if datatype == 0:
295 326 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
296 327 elif datatype == 1:
@@ -306,11 +337,11 class JRODataReader(JRODataIO):
306 337 else:
307 338 raise ValueError, 'Data type was not defined'
308 339
309 self.dataType = datatype_str
310 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
311 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
312 # self.dataOutObj.channelList = numpy.arange(self.m_SystemHeader.numChannels)
313 # self.dataOutObj.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
340 self.dtype = datatype_str
341 self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
342 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
343 # self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
344 # self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
314 345 self.getBlockDimension()
315 346
316 347
@@ -324,22 +355,22 class JRODataReader(JRODataIO):
324 355 print "The file %s can't be opened" % (filename)
325 356 return False
326 357
327 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
358 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
328 359
329 360 if neededSize == 0:
330 m_BasicHeader = BasicHeader()
331 m_SystemHeader = SystemHeader()
332 m_RadarControllerHeader = RadarControllerHeader()
333 m_ProcessingHeader = ProcessingHeader()
361 basicHeaderObj = BasicHeader()
362 systemHeaderObj = SystemHeader()
363 radarControllerHeaderObj = RadarControllerHeader()
364 processingHeaderObj = ProcessingHeader()
334 365
335 366 try:
336 if not( m_BasicHeader.read(fp) ): raise ValueError
337 if not( m_SystemHeader.read(fp) ): raise ValueError
338 if not( m_RadarControllerHeader.read(fp) ): raise ValueError
339 if not( m_ProcessingHeader.read(fp) ): raise ValueError
340 data_type = int(numpy.log2((m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
367 if not( basicHeaderObj.read(fp) ): raise ValueError
368 if not( systemHeaderObj.read(fp) ): raise ValueError
369 if not( radarControllerHeaderObj.read(fp) ): raise ValueError
370 if not( processingHeaderObj.read(fp) ): raise ValueError
371 data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
341 372
342 neededSize = m_ProcessingHeader.blockSize + m_BasicHeader.size
373 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
343 374
344 375 except:
345 376 if msgFlag:
@@ -360,16 +391,274 class JRODataReader(JRODataIO):
360 391
361 392 return True
362 393
394 class JRODataWriter(JRODataIO):
395
396 """
397 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
398 de los datos siempre se realiza por bloques.
399 """
400
401 blockIndex = 0
402
403 setFile = None
404
405
406 def __init__(self, dataOutObj=None):
407 raise ValueError, "Not implemented"
408
409
410 def hasAllDataInBuffer(self):
411 raise ValueError, "Not implemented"
412
413
414 def setBlockDimension(self):
415 raise ValueError, "Not implemented"
416
417
418 def writeBlock(self):
419 raise ValueError, "No implemented"
420
421
422 def putData(self):
423 raise ValueError, "No implemented"
424
425
426 def __writeFirstHeader(self):
427 """
428 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
429
430 Affected:
431 __dataType
432
433 Return:
434 None
435 """
436
437 # CALCULAR PARAMETROS
438
439 sizeLongHeader = 0#XXXX
440 self.basicHeaderObj.size = 24 + sizeLongHeader
441
442 self.__writeBasicHeader()
443 self.__wrSystemHeader()
444 self.__wrRadarControllerHeader()
445 self.__wrProcessingHeader()
446 self.dtype = self.dataOutObj.dtype
447
448
449 def __writeBasicHeader(self, fp=None):
450 """
451 Escribe solo el Basic header en el file creado
452
453 Return:
454 None
455 """
456 if fp == None:
457 fp = self.fp
458
459 self.dataOutObj.basicHeaderObj.write(fp)
460
461
462 def __wrSystemHeader(self, fp=None):
463 """
464 Escribe solo el System header en el file creado
465
466 Return:
467 None
468 """
469 if fp == None:
470 fp = self.fp
471
472 self.dataOutObj.systemHeaderObj.write(fp)
473
474
475 def __wrRadarControllerHeader(self, fp=None):
476 """
477 Escribe solo el RadarController header en el file creado
478
479 Return:
480 None
481 """
482 if fp == None:
483 fp = self.fp
484
485 self.dataOutObj.radarControllerHeaderObj.write(fp)
486
487
488 def __wrProcessingHeader(self, fp=None):
489 """
490 Escribe solo el Processing header en el file creado
491
492 Return:
493 None
494 """
495 if fp == None:
496 fp = self.fp
497
498 self.dataOutObj.processingHeaderObj.write(fp)
499
500
501 def setNextFile(self):
502 """
503 Determina el siguiente file que sera escrito
504
505 Affected:
506 self.filename
507 self.subfolder
508 self.fp
509 self.setFile
510 self.flagIsNewFile
511
512 Return:
513 0 : Si el archivo no puede ser escrito
514 1 : Si el archivo esta listo para ser escrito
515 """
516 ext = self.ext
517 path = self.path
518
519 if self.fp != None:
520 self.fp.close()
521
522 timeTuple = time.localtime( self.dataOutObj.dataUtcTime)
523 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
524
525 doypath = os.path.join( path, subfolder )
526 if not( os.path.exists(doypath) ):
527 os.mkdir(doypath)
528 self.setFile = -1 #inicializo mi contador de seteo
529 else:
530 filesList = os.listdir( doypath )
531 if len( filesList ) > 0:
532 filesList = sorted( filesList, key=str.lower )
533 filen = filesList[-1]
534 # el filename debera tener el siguiente formato
535 # 0 1234 567 89A BCDE (hex)
536 # x YYYY DDD SSS .ext
537 if isNumber( filen[8:11] ):
538 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
539 else:
540 self.setFile = -1
541 else:
542 self.setFile = -1 #inicializo mi contador de seteo
543
544 setFile = self.setFile
545 setFile += 1
546
547 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
548 timeTuple.tm_year,
549 timeTuple.tm_yday,
550 setFile,
551 ext )
552
553 filename = os.path.join( path, subfolder, file )
554
555 fp = open( filename,'wb' )
556
557 self.blockIndex = 0
558
559 #guardando atributos
560 self.filename = filename
561 self.subfolder = subfolder
562 self.fp = fp
563 self.setFile = setFile
564 self.flagIsNewFile = 1
565
566 print 'Writing the file: %s'%self.filename
567
568 self.__writeFirstHeader()
569
570 return 1
571
363 572
573 def __setNewBlock(self):
574 """
575 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
576
577 Return:
578 0 : si no pudo escribir nada
579 1 : Si escribio el Basic el First Header
580 """
581 if self.fp == None:
582 self.setNextFile()
583
584 if self.flagIsNewFile:
585 return 1
586
587 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
588 self.__writeBasicHeader()
589 return 1
590
591 if not( self.setNextFile() ):
592 return 0
593
594 return 1
364 595
365 def updateDataHeader(self):
366 self.dataOutObj.m_BasicHeader = self.m_BasicHeader.copy()
367 self.dataOutObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
368 self.dataOutObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
369 self.dataOutObj.m_SystemHeader = self.m_SystemHeader.copy()
370 self.dataOutObj.dataType = self.dataType
371 self.dataOutObj.updateObjFromHeader() # actualiza los atributos del objeto de salida de la clase JROData
372 596
597 def writeNextBlock(self):
598 """
599 Selecciona el bloque siguiente de datos y los escribe en un file
600
601 Return:
602 0 : Si no hizo pudo escribir el bloque de datos
603 1 : Si no pudo escribir el bloque de datos
604 """
605 if not( self.__setNewBlock() ):
606 return 0
607
608 self.writeBlock()
609
610 return 1
611
612
613 def getDataHeader(self):
614 """
615 Obtiene una copia del First Header
616
617 Affected:
618 self.basicHeaderObj
619 self.systemHeaderObj
620 self.radarControllerHeaderObj
621 self.processingHeaderObj
622 self.dtype
623
624 Return:
625 None
626 """
627
628 raise ValueError, "No implemented"
629
630 def setup(self, path, set=0, ext=None):
631 """
632 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
633
634 Inputs:
635 path : el path destino en el cual se escribiran los files a crear
636 format : formato en el cual sera salvado un file
637 set : el setebo del file
638
639 Return:
640 0 : Si no realizo un buen seteo
641 1 : Si realizo un buen seteo
642 """
643
644 if ext == None:
645 ext = self.ext
646
647 ext = ext.lower()
648
649 self.path = path
650 self.setFile = set - 1
651 self.ext = ext
652 #self.format = format
653 self.getDataHeader()
654
655 self.setBlockDimension()
656
657 if not( self.setNextFile() ):
658 print "There isn't a next file"
659 return 0
660
661 return 1
373 662
374 663
375 664
Show file before | Show file after | Hide comments
@@ -35,6 +35,7 class BasicHeader(Header):
35 35 struct = None
36 36
37 37 def __init__(self):
38
38 39 self.size = 0
39 40 self.version = 0
40 41 self.dataBlock = 0
@@ -81,18 +82,18 class BasicHeader(Header):
81 82 class SystemHeader(Header):
82 83
83 84 size = None
84 numSamples = None
85 numProfiles = None
86 numChannels = None
85 nSamples = None
86 nProfiles = None
87 nChannels = None
87 88 adcResolution = None
88 89 pciDioBusWidth = None
89 90 struct = None
90 91
91 92 def __init__(self):
92 93 self.size = 0
93 self.numSamples = 0
94 self.numProfiles = 0
95 self.numChannels = 0
94 self.nSamples = 0
95 self.nProfiles = 0
96 self.nChannels = 0
96 97 self.adcResolution = 0
97 98 self.pciDioBusWidth = 0
98 99 self.struct = numpy.dtype([
@@ -109,9 +110,9 class SystemHeader(Header):
109 110 try:
110 111 header = numpy.fromfile(fp,self.struct,1)
111 112 self.size = header['nSize'][0]
112 self.numSamples = header['nNumSamples'][0]
113 self.numProfiles = header['nNumProfiles'][0]
114 self.numChannels = header['nNumChannels'][0]
113 self.nSamples = header['nNumSamples'][0]
114 self.nProfiles = header['nNumProfiles'][0]
115 self.nChannels = header['nNumChannels'][0]
115 116 self.adcResolution = header['nADCResolution'][0]
116 117 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
117 118 except:
@@ -120,7 +121,7 class SystemHeader(Header):
120 121 return 1
121 122
122 123 def write(self, fp):
123 headerTuple = (self.size,self.numSamples,self.numProfiles,self.numChannels,self.adcResolution,self.pciDioBusWidth)
124 headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
124 125 header = numpy.array(headerTuple,self.struct)
125 126 header.tofile(fp)
126 127
@@ -134,7 +135,7 class RadarControllerHeader(Header):
134 135 ipp = None
135 136 txA = None
136 137 txB = None
137 numWindows = None
138 nWindows = None
138 139 numTaus = None
139 140 codeType = None
140 141 line6Function = None
@@ -154,7 +155,7 class RadarControllerHeader(Header):
154 155 self.ipp = 0
155 156 self.txA = 0
156 157 self.txB = 0
157 self.numWindows = 0
158 self.nWindows = 0
158 159 self.numTaus = 0
159 160 self.codeType = 0
160 161 self.line6Function = 0
@@ -212,7 +213,7 class RadarControllerHeader(Header):
212 213 self.ipp = header['fIpp'][0]
213 214 self.txA = header['fTxA'][0]
214 215 self.txB = header['fTxB'][0]
215 self.numWindows = header['nNumWindows'][0]
216 self.nWindows = header['nNumWindows'][0]
216 217 self.numTaus = header['nNumTaus'][0]
217 218 self.codeType = header['nCodeType'][0]
218 219 self.line6Function = header['nLine6Function'][0]
@@ -230,7 +231,7 class RadarControllerHeader(Header):
230 231 backFp = fp.tell() - jumpFp
231 232 fp.seek(backFp)
232 233
233 self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.numWindows)
234 self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
234 235 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
235 236 self.firstHeight = self.samplingWindow['h0']
236 237 self.deltaHeight = self.samplingWindow['dh']
@@ -272,7 +273,7 class RadarControllerHeader(Header):
272 273 self.ipp,
273 274 self.txA,
274 275 self.txB,
275 self.numWindows,
276 self.nWindows,
276 277 self.numTaus,
277 278 self.codeType,
278 279 self.line6Function,
@@ -297,14 +298,14 class RadarControllerHeader(Header):
297 298 class ProcessingHeader(Header):
298 299
299 300 size = None
300 dataType = None
301 dtype = None
301 302 blockSize = None
302 303 profilesPerBlock = None
303 304 dataBlocksPerFile = None
304 numWindows = None
305 nWindows = None
305 306 processFlags = None
306 coherentInt = None
307 incoherentInt = None
307 nCohInt = None
308 nIncohInt = None
308 309 totalSpectra = None
309 310 struct = None
310 311 flag_dc = None
@@ -316,10 +317,10 class ProcessingHeader(Header):
316 317 self.blockSize = 0
317 318 self.profilesPerBlock = 0
318 319 self.dataBlocksPerFile = 0
319 self.numWindows = 0
320 self.nWindows = 0
320 321 self.processFlags = 0
321 self.coherentInt = 0
322 self.incoherentInt = 0
322 self.nCohInt = 0
323 self.nIncohInt = 0
323 324 self.totalSpectra = 0
324 325 self.struct = numpy.dtype([
325 326 ('nSize','<u4'),
@@ -355,12 +356,12 class ProcessingHeader(Header):
355 356 self.blockSize = header['nSizeOfDataBlock'][0]
356 357 self.profilesPerBlock = header['nProfilesperBlock'][0]
357 358 self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
358 self.numWindows = header['nNumWindows'][0]
359 self.nWindows = header['nNumWindows'][0]
359 360 self.processFlags = header['nProcessFlags']
360 self.coherentInt = header['nCoherentIntegrations'][0]
361 self.incoherentInt = header['nIncoherentIntegrations'][0]
361 self.nCohInt = header['nCoherentIntegrations'][0]
362 self.nIncohInt = header['nIncoherentIntegrations'][0]
362 363 self.totalSpectra = header['nTotalSpectra'][0]
363 self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.numWindows)
364 self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
364 365 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
365 366 self.firstHeight = self.samplingWindow['h0']
366 367 self.deltaHeight = self.samplingWindow['dh']
@@ -406,16 +407,16 class ProcessingHeader(Header):
406 407 self.blockSize,
407 408 self.profilesPerBlock,
408 409 self.dataBlocksPerFile,
409 self.numWindows,
410 self.nWindows,
410 411 self.processFlags,
411 self.coherentInt,
412 self.incoherentInt,
412 self.nCohInt,
413 self.nIncohInt,
413 414 self.totalSpectra)
414 415
415 416 header = numpy.array(headerTuple,self.struct)
416 417 header.tofile(fp)
417 418
418 if self.numWindows != 0:
419 if self.nWindows != 0:
419 420 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
420 421 samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
421 422 samplingWindow.tofile(fp)
Show file before | Show file after | Hide comments
@@ -1,3 +1,9
1 '''
2 Created on 23/01/2012
3
4 @author $Author: dsuarez $
5 @version $Id: VoltageIO.py 110 2012-07-19 15:18:18Z dsuarez $
6 '''
1 7
2 8 import os, sys
3 9 import numpy
@@ -8,34 +14,481 import time, datetime
8 14 path = os.path.split(os.getcwd())[0]
9 15 sys.path.append(path)
10 16
11 from Model.JROHeader import *
12 from Model.Voltage import Voltage
13
14 from IO.JRODataIO import JRODataReader
17 from JROHeader import *
18 from JRODataIO import JRODataReader
19 from JRODataIO import JRODataWriter
15 20
21 from Data.Voltage import Voltage
16 22
17 23 class VoltageReader(JRODataReader):
24 """
25 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
26 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
27 perfiles*alturas*canales) son almacenados en la variable "buffer".
28
29 perfiles * alturas * canales
30
31 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
32 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
33 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
34 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
35
36 Example:
37
38 dpath = "/home/myuser/data"
39
40 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
41
42 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
43
44 readerObj = VoltageReader()
45
46 readerObj.setup(dpath, startTime, endTime)
47
48 while(True):
49
50 #to get one profile
51 profile = readerObj.getData()
52
53 #print the profile
54 print profile
55
56 #If you want to see all datablock
57 print readerObj.datablock
58
59 if readerObj.flagNoMoreFiles:
60 break
61
62 """
18 63 dataOutObj = None
64
19 65 datablock = None
66
20 67 ext = ".r"
68
21 69 optchar = "D"
22
70
71
23 72 def __init__(self, dataOutObj=None):
73 """
74 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
75
76 Input:
77 dataOutObj : Objeto de la clase Voltage. Este objeto sera utilizado para
78 almacenar un perfil de datos cada vez que se haga un requerimiento
79 (getData). El perfil sera obtenido a partir del buffer de datos,
80 si el buffer esta vacio se hara un nuevo proceso de lectura de un
81 bloque de datos.
82 Si este parametro no es pasado se creara uno internamente.
83
84 Variables afectadas:
85 self.dataOutObj
86
87 Return:
88 None
89 """
90
24 91 self.datablock = None
25 #Por herencia no necesito instanciar nuevamente estos objetos
26 #self.m_BasicHeader = BasicHeader()
27 #self.m_SystemHeader = SystemHeader()
28 #self.m_RadarControllerHeader = RadarControllerHeader()
29 #self.m_ProcessingHeader = ProcessingHeader()
92
93 self.utc = 0
94
95 self.ext = ".r"
96
97 self.optchar = "D"
98
99 self.basicHeaderObj = BasicHeader()
100
101 self.systemHeaderObj = SystemHeader()
102
103 self.radarControllerHeaderObj = RadarControllerHeader()
104
105 self.processingHeaderObj = ProcessingHeader()
106
30 107 self.online = 0
108
109 self.fp = None
110
111 self.idFile = None
112
113 self.startDateTime = None
114
115 self.endDateTime = None
116
117 self.dtype = None
118
119 self.fileSizeByHeader = None
120
121 self.filenameList = []
122
123 self.filename = None
124
125 self.fileSize = None
126
127 self.firstHeaderSize = 0
128
129 self.basicHeaderSize = 24
130
131 self.pathList = []
132
133 self.filenameList = []
134
135 self.lastUTTime = 0
136
137 self.maxTimeStep = 30
138
139 self.flagNoMoreFiles = 0
140
141 self.set = 0
142
143 self.path = None
144
145 self.profileIndex = 9999
31 146
147 self.delay = 3 #seconds
148
149 self.nTries = 3 #quantity tries
150
151 self.nFiles = 3 #number of files for searching
152
153 self.nReadBlocks = 0
154
155 self.flagIsNewFile = 1
156
157 self.ippSeconds = 0
158
159 self.flagTimeBlock = 0
160
161 self.flagIsNewBlock = 0
162
163 self.nTotalBlocks = 0
164
165 self.blocksize = 0
166
32 167 def createObjByDefault(self):
168
33 169 dataObj = Voltage()
34
170
35 171 return dataObj
172
173 def __hasNotDataInBuffer(self):
174 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
175 return 1
176 return 0
177
36 178
37 179 def getBlockDimension(self):
38 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
180 """
181 Obtiene la cantidad de puntos a leer por cada bloque de datos
182
183 Affected:
184 self.blocksize
185
186 Return:
187 None
188 """
189 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.numHeights * self.systemHeaderObj.numChannels
39 190 self.blocksize = pts2read
191
192
193 def readBlock(self):
194 """
195 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
196 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
197 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
198 es seteado a 0
199
200 Inputs:
201 None
202
203 Return:
204 None
205
206 Affected:
207 self.profileIndex
208 self.datablock
209 self.flagIsNewFile
210 self.flagIsNewBlock
211 self.nTotalBlocks
212
213 Exceptions:
214 Si un bloque leido no es un bloque valido
215 """
216
217 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
40 218
219 try:
220 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.numHeights, self.systemHeaderObj.numChannels) )
221 except:
222 print "The read block (%3d) has not enough data" %self.nReadBlocks
223 return 0
224
225 junk = numpy.transpose(junk, (2,0,1))
226 self.datablock = junk['real'] + junk['imag']*1j
227
228 self.profileIndex = 0
229
230 self.flagIsNewFile = 0
231 self.flagIsNewBlock = 1
232
233 self.nTotalBlocks += 1
234 self.nReadBlocks += 1
235
236 return 1
41 237
238
239 def getData(self):
240 """
241 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
242 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
243 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
244
245 Ademas incrementa el contador del buffer en 1.
246
247 Return:
248 data : retorna un perfil de voltages (alturas * canales) copiados desde el
249 buffer. Si no hay mas archivos a leer retorna None.
250
251 Variables afectadas:
252 self.dataOutObj
253 self.profileIndex
254
255 Affected:
256 self.dataOutObj
257 self.profileIndex
258 self.flagTimeBlock
259 self.flagIsNewBlock
260 """
261 if self.flagNoMoreFiles: return 0
262
263 self.flagTimeBlock = 0
264 self.flagIsNewBlock = 0
265
266 if self.__hasNotDataInBuffer():
267
268 if not( self.readNextBlock() ):
269 return 0
270
271 self.updateDataHeader()
272
273 if self.flagNoMoreFiles == 1:
274 print 'Process finished'
275 return 0
276
277 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
278
279 if self.datablock == None:
280 self.dataOutObj.flagNoData = True
281 return 0
282
283 self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
284
285 self.dataOutObj.dtype = self.dtype
286
287 self.dataOutObj.nChannels = self.systemHeaderObj.numChannels
288
289 self.dataOutObj.nHeights = self.processingHeaderObj.numHeights
290
291 self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
292
293 xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.numHeights*self.processingHeaderObj.deltaHeight
294
295 self.dataOutObj.heightList = range(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
296
297 self.dataOutObj.channelList = range(self.systemHeaderObj.numChannels)
298
299 self.dataOutObj.channelIndexList = range(self.systemHeaderObj.numChannels)
300
301 self.dataOutObj.flagNoData = True
302
303 self.dataOutObj.flagTimeBlock = self.flagTimeBlock
304
305 self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.profileIndex * self.ippSeconds
306
307 self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
308
309 self.profileIndex += 1
310
311 self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
312
313 self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
314
315 return 1
316
317
318 class VoltageWriter(JRODataWriter):
319 """
320 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
321 de los datos siempre se realiza por bloques.
322 """
323 __configHeaderFile = 'wrSetHeadet.txt'
324
325 dataOutObj = None
326
327 ext = ".r"
328
329 optchar = "D"
330
331 datablock = None
332
333 profileIndex = 0
334
335 shapeBuffer = None
336
337
338 def __init__(self, dataOutObj=None):
339 """
340 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
341
342 Affected:
343 self.dataOutObj
344
345 Return: None
346 """
347 if dataOutObj == None:
348 dataOutObj = Voltage()
349
350 if not( isinstance(dataOutObj, Voltage) ):
351 raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
352
353 self.dataOutObj = dataOutObj
354
355
356 def hasAllDataInBuffer(self):
357 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
358 return 1
359 return 0
360
361
362 def setBlockDimension(self):
363 """
364 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
365
366 Affected:
367 self.shape_spc_Buffer
368 self.shape_cspc_Buffer
369 self.shape_dc_Buffer
370
371 Return: None
372 """
373 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
374 self.processingHeaderObj.numHeights,
375 self.systemHeaderObj.numChannels )
376
377 self.datablock = numpy.zeros((self.systemHeaderObj.numChannels,
378 self.processingHeaderObj.profilesPerBlock,
379 self.processingHeaderObj.numHeights),
380 dtype=numpy.dtype('complex'))
381
382
383 def writeBlock(self):
384 """
385 Escribe el buffer en el file designado
386
387 Affected:
388 self.profileIndex
389 self.flagIsNewFile
390 self.flagIsNewBlock
391 self.nTotalBlocks
392 self.blockIndex
393
394 Return: None
395 """
396 data = numpy.zeros( self.shapeBuffer, self.dtype )
397
398 junk = numpy.transpose(self.datablock, (1,2,0))
399
400 data['real'] = junk.real
401 data['imag'] = junk.imag
402
403 data = data.reshape( (-1) )
404
405 data.tofile( self.fp )
406
407 self.datablock.fill(0)
408
409 self.profileIndex = 0
410 self.flagIsNewFile = 0
411 self.flagIsNewBlock = 1
412
413 self.blockIndex += 1
414 self.nTotalBlocks += 1
415
416 def putData(self):
417 """
418 Setea un bloque de datos y luego los escribe en un file
419
420 Affected:
421 self.flagIsNewBlock
422 self.profileIndex
423
424 Return:
425 0 : Si no hay data o no hay mas files que puedan escribirse
426 1 : Si se escribio la data de un bloque en un file
427 """
428 self.flagIsNewBlock = 0
429
430 if self.dataOutObj.flagNoData:
431 return 0
432
433 if self.dataOutObj.flagTimeBlock:
434
435 self.datablock.fill(0)
436 self.profileIndex = 0
437 self.setNextFile()
438
439 self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
440
441 self.profileIndex += 1
442
443 if self.hasAllDataInBuffer():
444 #if self.flagIsNewFile:
445 self.getDataHeader()
446 self.writeNextBlock()
447
448 if self.flagNoMoreFiles:
449 #print 'Process finished'
450 return 0
451
452 return 1
453
454 def getDataHeader(self):
455
456 """
457 Obtiene una copia del First Header
458
459 Affected:
460 self.systemHeaderObj
461 self.radarControllerHeaderObj
462 self.dtype
463
464 Return:
465 None
466 """
467
468 # CALCULAR PARAMETROS
469
470 self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
471 self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
472
473 self.basicHeaderObj.size = self.basicHeaderSize
474 self.basicHeaderObj.version = self.versionFile
475 self.basicHeaderObj.dataBlock = self.nTotalBlocks
476 self.basicHeaderObj.utc = self.dataOutObj.dataUtcTime
477 self.basicHeaderObj.miliSecond = 0
478 self.basicHeaderObj.timeZone = 0
479 self.basicHeaderObj.dstFlag = 0
480 self.basicHeaderObj.errorCount = 0
481
482 self.processingHeaderObj.size = 0
483 self.processingHeaderObj.dtype = self.dataOutObj.dtype
484 self.processingHeaderObj.blockSize = 0
485 self.processingHeaderObj.profilesPerBlock = 0
486 self.processingHeaderObj.dataBlocksPerFile = 0
487 self.processingHeaderObj.numWindows = 0
488 self.processingHeaderObj.processFlags = 0
489 self.processingHeaderObj.coherentInt = 0
490 self.processingHeaderObj.incoherentInt = 0
491 self.processingHeaderObj.totalSpectra = 0
492
493 self.dtype = self.dataOutObj.dtype
494 No newline at end of file
Show file before | Show file after | Hide comments
@@ -5,7 +5,7 import numpy
5 5 path = os.path.split(os.getcwd())[0]
6 6 sys.path.append(path)
7 7
8 from Model.Voltage import Voltage
8 from Data.Voltage import Voltage
9 9
10 10
11 11 class VoltageProcessor:
Show file before | Show file after | Hide comments
@@ -21,6 +21,7 class TestSChain():
21 21
22 22 def setValues(self):
23 23 self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
24 self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING"
24 25
25 26 self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
26 27
@@ -31,8 +32,8 class TestSChain():
31 32 self.endTime = datetime.time(14,1,1)
32 33
33 34 def createObjects(self):
35
34 36 self.readerObj = VoltageReader()
35 self.voltProcObj = VoltageProcessor()
36 37
37 38 self.voltObj1 = self.readerObj.setup(
38 39 path = self.path,
General Comments 0
You need to be logged in to leave comments. Login now