##// END OF EJS Templates
schain-jc
RSS
inicializacion de atributos en el metodo __init__ de la clase IO.Voltage ...
Daniel Valdez -
r19:289a88179fc1
parent child
Show More
Show file before | Show file after | Hide comments
@@ -7,13 +7,13 Created on 23/01/2012
7
7
8
8
9 class DataReader:
9 class DataReader:
10
11 def __init__(self):
10 __buffer = 0
12 __buffer = 0
11 __buffer_count = 0
13 __buffer_count = 0
12 def __init__(self):
13 pass
14
14
15 class DataWriter:
15 class DataWriter:
16
17 def __init__(self):
16 __buffer = 0
18 __buffer = 0
17 __buffer_count = 0
19 __buffer_count = 0
No newline at end of file
18 def __init__(self):
19 pass No newline at end of file
Show file before | Show file after | Hide comments
@@ -46,15 +46,16 class PROCFLAG:
46
46
47 class BasicHeader:
47 class BasicHeader:
48
48
49 size = 0
49 def __init__(self):
50 version = 0
50 self.size = 0
51 dataBlock = 0
51 self.version = 0
52 utc = 0
52 self.dataBlock = 0
53 miliSecond = 0
53 self.utc = 0
54 timeZone = 0
54 self.miliSecond = 0
55 dstFlag = 0
55 self.timeZone = 0
56 errorCount = 0
56 self.dstFlag = 0
57 struct = numpy.dtype([
57 self.errorCount = 0
58 self.struct = numpy.dtype([
58 ('nSize','<u4'),
59 ('nSize','<u4'),
59 ('nVersion','<u2'),
60 ('nVersion','<u2'),
60 ('nDataBlockId','<u4'),
61 ('nDataBlockId','<u4'),
@@ -64,8 +65,6 class BasicHeader:
64 ('nDstflag','<i2'),
65 ('nDstflag','<i2'),
65 ('nErrorCount','<u4')
66 ('nErrorCount','<u4')
66 ])
67 ])
67
68 def __init__(self):
69 pass
68 pass
70
69
71 def read(self, fp):
70 def read(self, fp):
@@ -97,13 +96,15 class BasicHeader:
97 return obj
96 return obj
98
97
99 class SystemHeader:
98 class SystemHeader:
100 size = 0
99
101 numSamples = 0
100 def __init__(self):
102 numProfiles = 0
101 self.size = 0
103 numChannels = 0
102 self.numSamples = 0
104 adcResolution = 0
103 self.numProfiles = 0
105 pciDioBusWidth = 0
104 self.numChannels = 0
106 struct = numpy.dtype([
105 self.adcResolution = 0
106 self.pciDioBusWidth = 0
107 self.struct = numpy.dtype([
107 ('nSize','<u4'),
108 ('nSize','<u4'),
108 ('nNumSamples','<u4'),
109 ('nNumSamples','<u4'),
109 ('nNumProfiles','<u4'),
110 ('nNumProfiles','<u4'),
@@ -112,8 +113,6 class SystemHeader:
112 ('nPCDIOBusWidth','<u4'),
113 ('nPCDIOBusWidth','<u4'),
113 ])
114 ])
114
115
115 def __init__(self):
116 pass
117
116
118 def read(self, fp):
117 def read(self, fp):
119 header = numpy.fromfile(fp,self.struct,1)
118 header = numpy.fromfile(fp,self.struct,1)
@@ -141,24 +140,27 class SystemHeader:
141 return obj
140 return obj
142
141
143 class RadarControllerHeader:
142 class RadarControllerHeader:
144 size = 0
143
145 expType = 0
144
146 nTx = 0
145 def __init__(self):
147 ipp = 0
146 self.size = 0
148 txA = 0
147 self.expType = 0
149 txB = 0
148 self.nTx = 0
150 numWindows = 0
149 self.ipp = 0
151 numTaus = 0
150 self.txA = 0
152 codeType = 0
151 self.txB = 0
153 line6Function = 0
152 self.numWindows = 0
154 line5Fuction = 0
153 self.numTaus = 0
155 fClock = 0
154 self.codeType = 0
156 prePulseBefore = 0
155 self.line6Function = 0
157 prePulserAfter = 0
156 self.line5Fuction = 0
158 rangeIpp = 0
157 self.fClock = 0
159 rangeTxA = 0
158 self.prePulseBefore = 0
160 rangeTxB = 0
159 self.prePulserAfter = 0
161 struct = numpy.dtype([
160 self.rangeIpp = 0
161 self.rangeTxA = 0
162 self.rangeTxB = 0
163 self.struct = numpy.dtype([
162 ('nSize','<u4'),
164 ('nSize','<u4'),
163 ('nExpType','<u4'),
165 ('nExpType','<u4'),
164 ('nNTx','<u4'),
166 ('nNTx','<u4'),
@@ -179,9 +181,6 class RadarControllerHeader:
179 ])
181 ])
180
182
181
183
182 def __init__(self):
183 pass
184
185 def read(self, fp):
184 def read(self, fp):
186 header = numpy.fromfile(fp,self.struct,1)
185 header = numpy.fromfile(fp,self.struct,1)
187 self.size = header['nSize'][0]
186 self.size = header['nSize'][0]
@@ -231,17 +230,19 class RadarControllerHeader:
231 return obj
230 return obj
232
231
233 class ProcessingHeader:
232 class ProcessingHeader:
234 size = 0
233
235 dataType = 0
234 def __init__(self):
236 blockSize = 0
235 self.size = 0
237 profilesPerBlock = 0
236 self.dataType = 0
238 dataBlocksPerFile = 0
237 self.blockSize = 0
239 numWindows = 0
238 self.profilesPerBlock = 0
240 processFlags = 0
239 self.dataBlocksPerFile = 0
241 coherentInt = 0
240 self.numWindows = 0
242 incoherentInt = 0
241 self.processFlags = 0
243 totalSpectra = 0
242 self.coherentInt = 0
244 struct = numpy.dtype([
243 self.incoherentInt = 0
244 self.totalSpectra = 0
245 self.struct = numpy.dtype([
245 ('nSize','<u4'),
246 ('nSize','<u4'),
246 ('nDataType','<u4'),
247 ('nDataType','<u4'),
247 ('nSizeOfDataBlock','<u4'),
248 ('nSizeOfDataBlock','<u4'),
@@ -253,19 +254,16 class ProcessingHeader:
253 ('nIncoherentIntegrations','<u4'),
254 ('nIncoherentIntegrations','<u4'),
254 ('nTotalSpectra','<u4')
255 ('nTotalSpectra','<u4')
255 ])
256 ])
256 samplingWindow = 0
257 self.samplingWindow = 0
257 structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
258 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
258 numHeights = 0
259 self.numHeights = 0
259 firstHeight = 0
260 self.firstHeight = 0
260 deltaHeight = 0
261 self.deltaHeight = 0
261 samplesWin = 0
262 self.samplesWin = 0
262 spectraComb = 0
263 self.spectraComb = 0
263 numCode = 0
264 self.numCode = 0
264 codes = 0
265 self.codes = 0
265 numBaud = 0
266 self.numBaud = 0
266
267 def __init__(self):
268 pass
269
267
270 def read(self, fp):
268 def read(self, fp):
271 header = numpy.fromfile(fp,self.struct,1)
269 header = numpy.fromfile(fp,self.struct,1)
Show file before | Show file after | Hide comments
@@ -23,68 +23,66 from Model.Voltage import Voltage
23
23
24 class VoltageReader(DataReader):
24 class VoltageReader(DataReader):
25
25
26 __idFile = None
26 def __init__(self, m_Voltage = None):
27
28 __fp = None
29
27
30 __startDateTime = None
28 if m_Voltage == None:
29 m_Voltage = Voltage()
31
30
32 __endDateTime = None
31 self.m_Voltage = m_Voltage
33
32
34 __dataType = None
33 self.__idFile = None
35
34
36 __fileSizeByHeader = 0
35 self.__fp = None
37
36
38 __pathList = []
37 self.__startDateTime = None
39
38
40 filenameList = []
39 self.__endDateTime = None
41
40
42 __lastUTTime = 0
41 self.__dataType = None
43
42
44 __maxTimeStep = 5
43 self.__fileSizeByHeader = 0
45
44
46 __flagIsNewFile = 0
45 self.__pathList = []
47
46
48 __ippSeconds = 0
47 self.filenameList = []
49
48
50 flagResetProcessing = 0
49 self.__lastUTTime = 0
51
50
52 flagIsNewBlock = 0
51 self.__maxTimeStep = 5
53
52
54 noMoreFiles = 0
53 self.__flagIsNewFile = 0
55
54
56 nReadBlocks = 0
55 self.__ippSeconds = 0
57
56
58 online = 0
57 self.flagResetProcessing = 0
59
58
60 filename = None
59 self.flagIsNewBlock = 0
61
60
62 fileSize = None
61 self.noMoreFiles = 0
63
62
64 firstHeaderSize = 0
63 self.nReadBlocks = 0
65
64
66 basicHeaderSize = 24
65 self.online = 0
67
66
68 m_BasicHeader = BasicHeader()
67 self.filename = None
69
68
70 m_SystemHeader = SystemHeader()
69 self.fileSize = None
71
70
72 m_RadarControllerHeader = RadarControllerHeader()
71 self.firstHeaderSize = 0
73
72
74 m_ProcessingHeader = ProcessingHeader()
73 self.basicHeaderSize = 24
75
74
76 m_Voltage = None
75 self.m_BasicHeader = BasicHeader()
77
76
78 __buffer = 0
77 self.m_SystemHeader = SystemHeader()
79
78
80 __buffer_id = 9999
79 self.m_RadarControllerHeader = RadarControllerHeader()
81
80
82 def __init__(self, m_Voltage = None):
81 self.m_ProcessingHeader = ProcessingHeader()
83
82
84 if m_Voltage == None:
83 self.__buffer = 0
85 m_Voltage = Voltage()
86
84
87 self.m_Voltage = m_Voltage
85 self.__buffer_id = 9999
88
86
89 def __rdSystemHeader(self,fp=None):
87 def __rdSystemHeader(self,fp=None):
90 if fp == None:
88 if fp == None:
@@ -393,6 +391,7 class VoltageReader(DataReader):
393 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
391 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
394 self.m_Voltage.m_BasicHeader.utc = time
392 self.m_Voltage.m_BasicHeader.utc = time
395 self.m_Voltage.data = data
393 self.m_Voltage.data = data
394 self.m_Voltage.dataType = self.__dataType
396
395
397 self.__buffer_id += 1
396 self.__buffer_id += 1
398
397
@@ -439,22 +438,189 class VoltageReader(DataReader):
439
438
440 class VoltageWriter(DataWriter):
439 class VoltageWriter(DataWriter):
441
440
442 m_BasicHeader= BasicHeader()
443
441
442 def __init__(self, m_Voltage = None):
444
443
445 m_SystemHeader = SystemHeader()
444 if m_Voltage == None:
445 m_Voltage = Voltage()
446
446
447 self.m_Voltage = m_Voltage
447
448
448 m_RadarControllerHeader = RadarControllerHeader()
449 self.__fp = None
449
450
451 self.__blocksCounter = 0
450
452
451 m_ProcessingHeader = ProcessingHeader()
453 self.__setFile = None
452
454
453 m_Voltage = None
455 self.__flagIsNewFile = 0
454
456
455 def __init__(self, m_Voltage):
457 self.__buffer = 0
458
459 self.__buffer_id = 0
460
461 self.__dataType = None
462
463 self.__ext = None
464
465 self.nWriteBlocks = 0
466
467 self.flagIsNewBlock = 0
468
469 self.noMoreFiles = 0
470
471 self.filename = None
472
473 self.m_BasicHeader= BasicHeader()
474
475 self.m_SystemHeader = SystemHeader()
476
477 self.m_RadarControllerHeader = RadarControllerHeader()
478
479 self.m_ProcessingHeader = ProcessingHeader()
480
481 def __setNextFile(self):
482 setFile = self.__setFile
483 ext = self.__ext
484 path = self.__path
485
486 setFile += 1
487
488 if not(self.__blocksCounter >= self.m_ProcessingHeader.dataBlocksPerFile):
489 self.__fp.close()
490 return 0
491
492 timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
493 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_doy,setFile,ext)
494 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_doy)
495 tmp = os.path.join(path,subfolder)
496 if not(os.path.exists(tmp)):
497 os.mkdir(tmp)
498
499 filename = os.path.join(path,subfolder,file)
500 fp = open(filename,'wb')
501
502
503
504 #guardando atributos
505 self.filename = filename
506 self.__subfolder = subfolder
507 self.__fp = fp
508 self.__setFile = setFile
509 self.__flagIsNewFile = 1
510
511 print 'Writing the file: %s'%self.filename
512
513 return 1
514
515
516
517 def __setNewBlock(self):
518 if self.__fp == None:
519 return 0
520
521 if self.__flagIsNewFile:
522 return 1
523
524 #Bloques completados?
525 if self.__blocksCounter < self.m_ProcessingHeader.profilesPerBlock:
526 self.__writeBasicHeader()
527 return 1
528
529 if not(self.__setNextFile()):
530 return 0
531
532 self.__writeFirstHeader()
533
534 return 1
535
536 def __writeBlock(self):
537
538 numpy.save(self.__fp,self.__buffer)
539
540 self.__buffer = numpy.array([],self.__dataType)
541
542 self.__buffer_id = 0
543
544 self.__flagIsNewFile = 0
545
546 self.flagIsNewBlock = 1
547
548 self.nWriteBlocks += 1
549
550 self.__blocksCounter += 1
551
552 def writeNextBlock(self):
553 if not(self.__setNewBlock()):
554 return 0
555
556 self.__writeBlock()
557
558 return 1
559
560 def __hasAllDataInBuffer(self):
561 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
562 return 1
563
564 return 0
565
566 def putData(self):
567 self.flagIsNewBlock = 0
568
569 if self.m_Voltage.noData:
570 return None
571
572 shape = self.m_Voltage.data.shape
573 data = numpy.zeros(shape,self.__dataType)
574 data['real'] = self.m_Voltage.data.real
575 data['imag'] = self.m_Voltage.data.imag
576 data = data.reshape((-1))
577
578 self.__buffer = numpy.hstack((self.__buffer,data))
579
580 self.__buffer_id += 1
581
582 if __hasAllDataInBuffer():
583 self.writeNextBlock()
584
585
586 if self.noMoreFiles:
587 print 'Process finished'
588 return None
589
590 return 1
591
592
593 def setup(self,path,set=None,format=None):
594
595 if set == None:
596 set = -1
597 else:
598 set -= 1
599
600 if format == 'hdf5':
601 ext = '.hdf5'
602 print 'call hdf5 library'
603 return 0
604
605 if format == 'rawdata':
606 ext = '.r'
607
608 #call to config_headers
609
610 self.__setFile = set
611
612 if not(self.__setNextFile()):
613 print "zzzzzzzzzzzz"
614 return 0
615
616 self.__writeFirstHeader() # dentro de esta funcion se debe setear e __dataType
617
618 self.__buffer = numpy.array([],self.__dataType)
456
619
457 self.m_Voltage = m_Voltage
458
620
459
621
622 def __writeBasicHeader(self):
623 pass
460
624
625 def __writeFirstHeader(self):
626 pass No newline at end of file
Show file before | Show file after | Hide comments
@@ -18,25 +18,30 class Voltage(Data):
18 '''
18 '''
19
19
20
20
21 m_RadarControllerHeader= RadarControllerHeader()
22
21
23 m_ProcessingHeader= ProcessingHeader()
24
22
25 m_SystemHeader= SystemHeader()
26
23
27 m_BasicHeader= BasicHeader()
24 def __init__(self):
25 '''
26 Constructor
27 '''
28
29 self.m_RadarControllerHeader= RadarControllerHeader()
30
31 self.m_ProcessingHeader= ProcessingHeader()
32
33 self.m_SystemHeader= SystemHeader()
34
35 self.m_BasicHeader= BasicHeader()
28
36
29 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
37 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
30 data = None
38 self.data = None
31
39
32 noData = True
40 self.dataType = None
41
42 self.noData = True
33
43
34
44
35 def __init__(self):
36 '''
37 Constructor
38 '''
39 pass
40
45
41 def copy(self):
46 def copy(self):
42 obj = Voltage()
47 obj = Voltage()
General Comments 0
You need to be logged in to leave comments. Login now