##// 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 import copy
2 import copy
3 import numpy
3 import numpy
4 from JROHeader import BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
5
4
6 class Data:
5 path = os.path.split(os.getcwd())[0]
7 def __init__(self):
6 sys.path.append(path)
8 pass
9
7
10 def copy(self, inputObj=None):
8 from IO.JROHeader import SystemHeader, RadarControllerHeader
11 if inputObj == None:
12 return copy.deepcopy(self)
13
9
14 for key in inputObj.__dict__.keys():
10 class JROData():
15 self.__dict__[key] = inputObj.__dict__[key]
11
12 # m_BasicHeader = BasicHeader()
13 # m_ProcessingHeader = ProcessingHeader()
16
14
17 def deepcopy(self):
15 systemHeaderObj = SystemHeader()
18 return copy.deepcopy(self)
16
17 radarControllerHeaderObj = RadarControllerHeader()
19
18
20 class JROData(Data):
21 data = None
19 data = None
22 # m_BasicHeader = BasicHeader()
20
23 # m_SystemHeader = SystemHeader()
24 # m_RadarControllerHeader = RadarControllerHeader()
25 # m_ProcessingHeader = ProcessingHeader()
26 type = None
21 type = None
27 dataType = None
22
28 heightList = None
23 dtype = None
29 channelIndexList = None
24
30 channelList = None
25 nChannels = None
26
31 nHeights = None
27 nHeights = None
28
32 nProfiles = None
29 nProfiles = None
33 nBlocksPerFile = None
30
34 nChannels = None
31 heightList = None
32
33 channelList = None
34
35 channelIndexList = None
36
35 flagNoData = False
37 flagNoData = False
36 flagResetProcessing = False
38
39 flagTimeBlock = False
40
41 dataUtcTime = None
37
42
38 def __init__(self):
43 def __init__(self):
44
39 raise ValueError, "This class has not been implemented"
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 import numpy
2 import numpy
3
4 path = os.path.split(os.getcwd())[0]
5 sys.path.append(path)
6
2 from JROData import JROData
7 from JROData import JROData
3 # No deberia importar los Headers
8 from IO.JROHeader import SystemHeader, RadarControllerHeader
9
4 class Voltage(JROData):
10 class Voltage(JROData):
5 data = None
11
6 nCohInt = None
12 nCohInt = None
7
13
8 def __init__(self):
14 def __init__(self):
9 self.type = "Voltage"
15 '''
10
16 Constructor
11 def updateObjFromHeader(self):
17 '''
12 xi = self.m_ProcessingHeader.firstHeight
18
13 step = self.m_ProcessingHeader.deltaHeight
19 self.m_RadarControllerHeader = RadarControllerHeader()
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
25
20
26 def updateHeaderFromObj(self):
21 self.m_SystemHeader = SystemHeader()
27 pass No newline at end of file
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 path = os.path.split(os.getcwd())[0]
8 path = os.path.split(os.getcwd())[0]
9 sys.path.append(path)
9 sys.path.append(path)
10
10
11 from Model.JROHeader import *
11 from JROHeader import *
12 from Model.JROData import JROData
12 from Data.JROData import JROData
13
13
14 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
14 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
15 """
15 """
@@ -32,21 +32,21 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
32 Si la cabecera no puede ser leida.
32 Si la cabecera no puede ser leida.
33
33
34 """
34 """
35 m_BasicHeader = BasicHeader()
35 basicHeaderObj = BasicHeader()
36
36
37 try:
37 try:
38 fp = open(filename,'rb')
38 fp = open(filename,'rb')
39 except:
39 except:
40 raise IOError, "The file %s can't be opened" %(filename)
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 fp.close()
43 fp.close()
44
44
45 if not(sts):
45 if not(sts):
46 print "Skipping the file %s because it has not a valid header" %(filename)
46 print "Skipping the file %s because it has not a valid header" %(filename)
47 return 0
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 return 0
50 return 0
51
51
52 return 1
52 return 1
@@ -55,28 +55,59 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
55
55
56
56
57 class JRODataIO:
57 class JRODataIO:
58
58 c = 3E8
59 c = 3E8
59 m_BasicHeader = BasicHeader()
60
60 m_SystemHeader = SystemHeader()
61 basicHeaderObj = BasicHeader()
61 m_RadarControllerHeader = RadarControllerHeader()
62
62 m_ProcessingHeader = ProcessingHeader()
63 systemHeaderObj = SystemHeader()
64
65 radarControllerHeaderObj = RadarControllerHeader()
66
67 processingHeaderObj = ProcessingHeader()
68
63 online = 0
69 online = 0
64 dataType = None
70
71 dtype = None
72
65 pathList = []
73 pathList = []
74
66 filenameList = []
75 filenameList = []
76
67 filename = None
77 filename = None
78
68 ext = None
79 ext = None
69 fileIndex = None
80
70 flagNoMoreFiles = 0
81 flagNoMoreFiles = 0
82
71 flagIsNewFile = 1
83 flagIsNewFile = 1
72 flagResetProcessing = 0
84
85 flagTimeBlock = 0
86
73 flagIsNewBlock = 0
87 flagIsNewBlock = 0
88
74 fp = None
89 fp = None
90
75 firstHeaderSize = 0
91 firstHeaderSize = 0
92
76 basicHeaderSize = 24
93 basicHeaderSize = 24
94
95 versionFile = 1103
96
77 fileSize = None
97 fileSize = None
98
78 ippSeconds = None
99 ippSeconds = None
100
79 fileSizeByHeader = None
101 fileSizeByHeader = None
102
103 fileIndex = None
104
105 profileIndex = None
106
107 blockIndex = None
108
109 nTotalBlocks = None
110
80 def __init__(self):
111 def __init__(self):
81 pass
112 pass
82
113
@@ -261,25 +292,25 class JRODataReader(JRODataIO):
261 if fp == None:
292 if fp == None:
262 fp = self.fp
293 fp = self.fp
263
294
264 self.m_ProcessingHeader.read(fp)
295 self.processingHeaderObj.read(fp)
265
296
266 def __rdRadarControllerHeader(self, fp=None):
297 def __rdRadarControllerHeader(self, fp=None):
267 if fp == None:
298 if fp == None:
268 fp = self.fp
299 fp = self.fp
269
300
270 self.m_RadarControllerHeader.read(fp)
301 self.radarControllerHeaderObj.read(fp)
271
302
272 def __rdSystemHeader(self, fp=None):
303 def __rdSystemHeader(self, fp=None):
273 if fp == None:
304 if fp == None:
274 fp = self.fp
305 fp = self.fp
275
306
276 self.m_SystemHeader.read(fp)
307 self.systemHeaderObj.read(fp)
277
308
278 def __rdBasicHeader(self, fp=None):
309 def __rdBasicHeader(self, fp=None):
279 if fp == None:
310 if fp == None:
280 fp = self.fp
311 fp = self.fp
281
312
282 self.m_BasicHeader.read(fp)
313 self.basicHeaderObj.read(fp)
283
314
284
315
285 def __readFirstHeader(self):
316 def __readFirstHeader(self):
@@ -288,9 +319,9 class JRODataReader(JRODataIO):
288 self.__rdRadarControllerHeader()
319 self.__rdRadarControllerHeader()
289 self.__rdProcessingHeader()
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 if datatype == 0:
325 if datatype == 0:
295 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
326 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
296 elif datatype == 1:
327 elif datatype == 1:
@@ -306,11 +337,11 class JRODataReader(JRODataIO):
306 else:
337 else:
307 raise ValueError, 'Data type was not defined'
338 raise ValueError, 'Data type was not defined'
308
339
309 self.dataType = datatype_str
340 self.dtype = datatype_str
310 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
341 self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
311 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
342 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
312 # self.dataOutObj.channelList = numpy.arange(self.m_SystemHeader.numChannels)
343 # self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
313 # self.dataOutObj.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
344 # self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
314 self.getBlockDimension()
345 self.getBlockDimension()
315
346
316
347
@@ -324,22 +355,22 class JRODataReader(JRODataIO):
324 print "The file %s can't be opened" % (filename)
355 print "The file %s can't be opened" % (filename)
325 return False
356 return False
326
357
327 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
358 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
328
359
329 if neededSize == 0:
360 if neededSize == 0:
330 m_BasicHeader = BasicHeader()
361 basicHeaderObj = BasicHeader()
331 m_SystemHeader = SystemHeader()
362 systemHeaderObj = SystemHeader()
332 m_RadarControllerHeader = RadarControllerHeader()
363 radarControllerHeaderObj = RadarControllerHeader()
333 m_ProcessingHeader = ProcessingHeader()
364 processingHeaderObj = ProcessingHeader()
334
365
335 try:
366 try:
336 if not( m_BasicHeader.read(fp) ): raise ValueError
367 if not( basicHeaderObj.read(fp) ): raise ValueError
337 if not( m_SystemHeader.read(fp) ): raise ValueError
368 if not( systemHeaderObj.read(fp) ): raise ValueError
338 if not( m_RadarControllerHeader.read(fp) ): raise ValueError
369 if not( radarControllerHeaderObj.read(fp) ): raise ValueError
339 if not( m_ProcessingHeader.read(fp) ): raise ValueError
370 if not( processingHeaderObj.read(fp) ): raise ValueError
340 data_type = int(numpy.log2((m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
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 except:
375 except:
345 if msgFlag:
376 if msgFlag:
@@ -360,16 +391,274 class JRODataReader(JRODataIO):
360
391
361 return True
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 struct = None
35 struct = None
36
36
37 def __init__(self):
37 def __init__(self):
38
38 self.size = 0
39 self.size = 0
39 self.version = 0
40 self.version = 0
40 self.dataBlock = 0
41 self.dataBlock = 0
@@ -81,18 +82,18 class BasicHeader(Header):
81 class SystemHeader(Header):
82 class SystemHeader(Header):
82
83
83 size = None
84 size = None
84 numSamples = None
85 nSamples = None
85 numProfiles = None
86 nProfiles = None
86 numChannels = None
87 nChannels = None
87 adcResolution = None
88 adcResolution = None
88 pciDioBusWidth = None
89 pciDioBusWidth = None
89 struct = None
90 struct = None
90
91
91 def __init__(self):
92 def __init__(self):
92 self.size = 0
93 self.size = 0
93 self.numSamples = 0
94 self.nSamples = 0
94 self.numProfiles = 0
95 self.nProfiles = 0
95 self.numChannels = 0
96 self.nChannels = 0
96 self.adcResolution = 0
97 self.adcResolution = 0
97 self.pciDioBusWidth = 0
98 self.pciDioBusWidth = 0
98 self.struct = numpy.dtype([
99 self.struct = numpy.dtype([
@@ -109,9 +110,9 class SystemHeader(Header):
109 try:
110 try:
110 header = numpy.fromfile(fp,self.struct,1)
111 header = numpy.fromfile(fp,self.struct,1)
111 self.size = header['nSize'][0]
112 self.size = header['nSize'][0]
112 self.numSamples = header['nNumSamples'][0]
113 self.nSamples = header['nNumSamples'][0]
113 self.numProfiles = header['nNumProfiles'][0]
114 self.nProfiles = header['nNumProfiles'][0]
114 self.numChannels = header['nNumChannels'][0]
115 self.nChannels = header['nNumChannels'][0]
115 self.adcResolution = header['nADCResolution'][0]
116 self.adcResolution = header['nADCResolution'][0]
116 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
117 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
117 except:
118 except:
@@ -120,7 +121,7 class SystemHeader(Header):
120 return 1
121 return 1
121
122
122 def write(self, fp):
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 header = numpy.array(headerTuple,self.struct)
125 header = numpy.array(headerTuple,self.struct)
125 header.tofile(fp)
126 header.tofile(fp)
126
127
@@ -134,7 +135,7 class RadarControllerHeader(Header):
134 ipp = None
135 ipp = None
135 txA = None
136 txA = None
136 txB = None
137 txB = None
137 numWindows = None
138 nWindows = None
138 numTaus = None
139 numTaus = None
139 codeType = None
140 codeType = None
140 line6Function = None
141 line6Function = None
@@ -154,7 +155,7 class RadarControllerHeader(Header):
154 self.ipp = 0
155 self.ipp = 0
155 self.txA = 0
156 self.txA = 0
156 self.txB = 0
157 self.txB = 0
157 self.numWindows = 0
158 self.nWindows = 0
158 self.numTaus = 0
159 self.numTaus = 0
159 self.codeType = 0
160 self.codeType = 0
160 self.line6Function = 0
161 self.line6Function = 0
@@ -212,7 +213,7 class RadarControllerHeader(Header):
212 self.ipp = header['fIpp'][0]
213 self.ipp = header['fIpp'][0]
213 self.txA = header['fTxA'][0]
214 self.txA = header['fTxA'][0]
214 self.txB = header['fTxB'][0]
215 self.txB = header['fTxB'][0]
215 self.numWindows = header['nNumWindows'][0]
216 self.nWindows = header['nNumWindows'][0]
216 self.numTaus = header['nNumTaus'][0]
217 self.numTaus = header['nNumTaus'][0]
217 self.codeType = header['nCodeType'][0]
218 self.codeType = header['nCodeType'][0]
218 self.line6Function = header['nLine6Function'][0]
219 self.line6Function = header['nLine6Function'][0]
@@ -230,7 +231,7 class RadarControllerHeader(Header):
230 backFp = fp.tell() - jumpFp
231 backFp = fp.tell() - jumpFp
231 fp.seek(backFp)
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 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
235 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
235 self.firstHeight = self.samplingWindow['h0']
236 self.firstHeight = self.samplingWindow['h0']
236 self.deltaHeight = self.samplingWindow['dh']
237 self.deltaHeight = self.samplingWindow['dh']
@@ -272,7 +273,7 class RadarControllerHeader(Header):
272 self.ipp,
273 self.ipp,
273 self.txA,
274 self.txA,
274 self.txB,
275 self.txB,
275 self.numWindows,
276 self.nWindows,
276 self.numTaus,
277 self.numTaus,
277 self.codeType,
278 self.codeType,
278 self.line6Function,
279 self.line6Function,
@@ -297,14 +298,14 class RadarControllerHeader(Header):
297 class ProcessingHeader(Header):
298 class ProcessingHeader(Header):
298
299
299 size = None
300 size = None
300 dataType = None
301 dtype = None
301 blockSize = None
302 blockSize = None
302 profilesPerBlock = None
303 profilesPerBlock = None
303 dataBlocksPerFile = None
304 dataBlocksPerFile = None
304 numWindows = None
305 nWindows = None
305 processFlags = None
306 processFlags = None
306 coherentInt = None
307 nCohInt = None
307 incoherentInt = None
308 nIncohInt = None
308 totalSpectra = None
309 totalSpectra = None
309 struct = None
310 struct = None
310 flag_dc = None
311 flag_dc = None
@@ -316,10 +317,10 class ProcessingHeader(Header):
316 self.blockSize = 0
317 self.blockSize = 0
317 self.profilesPerBlock = 0
318 self.profilesPerBlock = 0
318 self.dataBlocksPerFile = 0
319 self.dataBlocksPerFile = 0
319 self.numWindows = 0
320 self.nWindows = 0
320 self.processFlags = 0
321 self.processFlags = 0
321 self.coherentInt = 0
322 self.nCohInt = 0
322 self.incoherentInt = 0
323 self.nIncohInt = 0
323 self.totalSpectra = 0
324 self.totalSpectra = 0
324 self.struct = numpy.dtype([
325 self.struct = numpy.dtype([
325 ('nSize','<u4'),
326 ('nSize','<u4'),
@@ -355,12 +356,12 class ProcessingHeader(Header):
355 self.blockSize = header['nSizeOfDataBlock'][0]
356 self.blockSize = header['nSizeOfDataBlock'][0]
356 self.profilesPerBlock = header['nProfilesperBlock'][0]
357 self.profilesPerBlock = header['nProfilesperBlock'][0]
357 self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
358 self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
358 self.numWindows = header['nNumWindows'][0]
359 self.nWindows = header['nNumWindows'][0]
359 self.processFlags = header['nProcessFlags']
360 self.processFlags = header['nProcessFlags']
360 self.coherentInt = header['nCoherentIntegrations'][0]
361 self.nCohInt = header['nCoherentIntegrations'][0]
361 self.incoherentInt = header['nIncoherentIntegrations'][0]
362 self.nIncohInt = header['nIncoherentIntegrations'][0]
362 self.totalSpectra = header['nTotalSpectra'][0]
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 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
365 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
365 self.firstHeight = self.samplingWindow['h0']
366 self.firstHeight = self.samplingWindow['h0']
366 self.deltaHeight = self.samplingWindow['dh']
367 self.deltaHeight = self.samplingWindow['dh']
@@ -406,16 +407,16 class ProcessingHeader(Header):
406 self.blockSize,
407 self.blockSize,
407 self.profilesPerBlock,
408 self.profilesPerBlock,
408 self.dataBlocksPerFile,
409 self.dataBlocksPerFile,
409 self.numWindows,
410 self.nWindows,
410 self.processFlags,
411 self.processFlags,
411 self.coherentInt,
412 self.nCohInt,
412 self.incoherentInt,
413 self.nIncohInt,
413 self.totalSpectra)
414 self.totalSpectra)
414
415
415 header = numpy.array(headerTuple,self.struct)
416 header = numpy.array(headerTuple,self.struct)
416 header.tofile(fp)
417 header.tofile(fp)
417
418
418 if self.numWindows != 0:
419 if self.nWindows != 0:
419 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
420 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
420 samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
421 samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
421 samplingWindow.tofile(fp)
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 import os, sys
8 import os, sys
3 import numpy
9 import numpy
@@ -8,34 +14,481 import time, datetime
8 path = os.path.split(os.getcwd())[0]
14 path = os.path.split(os.getcwd())[0]
9 sys.path.append(path)
15 sys.path.append(path)
10
16
11 from Model.JROHeader import *
17 from JROHeader import *
12 from Model.Voltage import Voltage
18 from JRODataIO import JRODataReader
13
19 from JRODataIO import JRODataWriter
14 from IO.JRODataIO import JRODataReader
15
20
21 from Data.Voltage import Voltage
16
22
17 class VoltageReader(JRODataReader):
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 dataOutObj = None
63 dataOutObj = None
64
19 datablock = None
65 datablock = None
66
20 ext = ".r"
67 ext = ".r"
68
21 optchar = "D"
69 optchar = "D"
22
70
71
23 def __init__(self, dataOutObj=None):
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 self.datablock = None
91 self.datablock = None
25 #Por herencia no necesito instanciar nuevamente estos objetos
92
26 #self.m_BasicHeader = BasicHeader()
93 self.utc = 0
27 #self.m_SystemHeader = SystemHeader()
94
28 #self.m_RadarControllerHeader = RadarControllerHeader()
95 self.ext = ".r"
29 #self.m_ProcessingHeader = ProcessingHeader()
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 self.online = 0
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 def createObjByDefault(self):
167 def createObjByDefault(self):
168
33 dataObj = Voltage()
169 dataObj = Voltage()
34
170
35 return dataObj
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 def getBlockDimension(self):
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 self.blocksize = pts2read
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 path = os.path.split(os.getcwd())[0]
5 path = os.path.split(os.getcwd())[0]
6 sys.path.append(path)
6 sys.path.append(path)
7
7
8 from Model.Voltage import Voltage
8 from Data.Voltage import Voltage
9
9
10
10
11 class VoltageProcessor:
11 class VoltageProcessor:
Show file before | Show file after | Hide comments
@@ -21,6 +21,7 class TestSChain():
21
21
22 def setValues(self):
22 def setValues(self):
23 self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
23 self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
24 self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING"
24
25
25 self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
26 self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
26
27
@@ -31,8 +32,8 class TestSChain():
31 self.endTime = datetime.time(14,1,1)
32 self.endTime = datetime.time(14,1,1)
32
33
33 def createObjects(self):
34 def createObjects(self):
35
34 self.readerObj = VoltageReader()
36 self.readerObj = VoltageReader()
35 self.voltProcObj = VoltageProcessor()
36
37
37 self.voltObj1 = self.readerObj.setup(
38 self.voltObj1 = self.readerObj.setup(
38 path = self.path,
39 path = self.path,
General Comments 0
You need to be logged in to leave comments. Login now