##// END OF EJS Templates
schain
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 9 class DataReader:
10 __buffer = 0
11 __buffer_count = 0
10
12 11 def __init__(self):
13 pass
12 __buffer = 0
13 __buffer_count = 0
14 14
15 15 class DataWriter:
16 __buffer = 0
17 __buffer_count = 0
16
18 17 def __init__(self):
19 pass No newline at end of file
18 __buffer = 0
19 __buffer_count = 0 No newline at end of file
Show file before | Show file after | Hide comments
@@ -46,26 +46,25 class PROCFLAG:
46 46
47 47 class BasicHeader:
48 48
49 size = 0
50 version = 0
51 dataBlock = 0
52 utc = 0
53 miliSecond = 0
54 timeZone = 0
55 dstFlag = 0
56 errorCount = 0
57 struct = numpy.dtype([
58 ('nSize','<u4'),
59 ('nVersion','<u2'),
60 ('nDataBlockId','<u4'),
61 ('nUtime','<u4'),
62 ('nMilsec','<u2'),
63 ('nTimezone','<i2'),
64 ('nDstflag','<i2'),
65 ('nErrorCount','<u4')
66 ])
67
68 49 def __init__(self):
50 self.size = 0
51 self.version = 0
52 self.dataBlock = 0
53 self.utc = 0
54 self.miliSecond = 0
55 self.timeZone = 0
56 self.dstFlag = 0
57 self.errorCount = 0
58 self.struct = numpy.dtype([
59 ('nSize','<u4'),
60 ('nVersion','<u2'),
61 ('nDataBlockId','<u4'),
62 ('nUtime','<u4'),
63 ('nMilsec','<u2'),
64 ('nTimezone','<i2'),
65 ('nDstflag','<i2'),
66 ('nErrorCount','<u4')
67 ])
69 68 pass
70 69
71 70 def read(self, fp):
@@ -97,23 +96,23 class BasicHeader:
97 96 return obj
98 97
99 98 class SystemHeader:
100 size = 0
101 numSamples = 0
102 numProfiles = 0
103 numChannels = 0
104 adcResolution = 0
105 pciDioBusWidth = 0
106 struct = numpy.dtype([
107 ('nSize','<u4'),
108 ('nNumSamples','<u4'),
109 ('nNumProfiles','<u4'),
110 ('nNumChannels','<u4'),
111 ('nADCResolution','<u4'),
112 ('nPCDIOBusWidth','<u4'),
113 ])
114 99
115 100 def __init__(self):
116 pass
101 self.size = 0
102 self.numSamples = 0
103 self.numProfiles = 0
104 self.numChannels = 0
105 self.adcResolution = 0
106 self.pciDioBusWidth = 0
107 self.struct = numpy.dtype([
108 ('nSize','<u4'),
109 ('nNumSamples','<u4'),
110 ('nNumProfiles','<u4'),
111 ('nNumChannels','<u4'),
112 ('nADCResolution','<u4'),
113 ('nPCDIOBusWidth','<u4'),
114 ])
115
117 116
118 117 def read(self, fp):
119 118 header = numpy.fromfile(fp,self.struct,1)
@@ -141,46 +140,46 class SystemHeader:
141 140 return obj
142 141
143 142 class RadarControllerHeader:
144 size = 0
145 expType = 0
146 nTx = 0
147 ipp = 0
148 txA = 0
149 txB = 0
150 numWindows = 0
151 numTaus = 0
152 codeType = 0
153 line6Function = 0
154 line5Fuction = 0
155 fClock = 0
156 prePulseBefore = 0
157 prePulserAfter = 0
158 rangeIpp = 0
159 rangeTxA = 0
160 rangeTxB = 0
161 struct = numpy.dtype([
162 ('nSize','<u4'),
163 ('nExpType','<u4'),
164 ('nNTx','<u4'),
165 ('fIpp','<f4'),
166 ('fTxA','<f4'),
167 ('fTxB','<f4'),
168 ('nNumWindows','<u4'),
169 ('nNumTaus','<u4'),
170 ('nCodeType','<u4'),
171 ('nLine6Function','<u4'),
172 ('nLine5Function','<u4'),
173 ('fClock','<f4'),
174 ('nPrePulseBefore','<u4'),
175 ('nPrePulseAfter','<u4'),
176 ('sRangeIPP','<a20'),
177 ('sRangeTxA','<a20'),
178 ('sRangeTxB','<a20'),
179 ])
180 143
181 144
182 145 def __init__(self):
183 pass
146 self.size = 0
147 self.expType = 0
148 self.nTx = 0
149 self.ipp = 0
150 self.txA = 0
151 self.txB = 0
152 self.numWindows = 0
153 self.numTaus = 0
154 self.codeType = 0
155 self.line6Function = 0
156 self.line5Fuction = 0
157 self.fClock = 0
158 self.prePulseBefore = 0
159 self.prePulserAfter = 0
160 self.rangeIpp = 0
161 self.rangeTxA = 0
162 self.rangeTxB = 0
163 self.struct = numpy.dtype([
164 ('nSize','<u4'),
165 ('nExpType','<u4'),
166 ('nNTx','<u4'),
167 ('fIpp','<f4'),
168 ('fTxA','<f4'),
169 ('fTxB','<f4'),
170 ('nNumWindows','<u4'),
171 ('nNumTaus','<u4'),
172 ('nCodeType','<u4'),
173 ('nLine6Function','<u4'),
174 ('nLine5Function','<u4'),
175 ('fClock','<f4'),
176 ('nPrePulseBefore','<u4'),
177 ('nPrePulseAfter','<u4'),
178 ('sRangeIPP','<a20'),
179 ('sRangeTxA','<a20'),
180 ('sRangeTxB','<a20'),
181 ])
182
184 183
185 184 def read(self, fp):
186 185 header = numpy.fromfile(fp,self.struct,1)
@@ -231,41 +230,40 class RadarControllerHeader:
231 230 return obj
232 231
233 232 class ProcessingHeader:
234 size = 0
235 dataType = 0
236 blockSize = 0
237 profilesPerBlock = 0
238 dataBlocksPerFile = 0
239 numWindows = 0
240 processFlags = 0
241 coherentInt = 0
242 incoherentInt = 0
243 totalSpectra = 0
244 struct = numpy.dtype([
245 ('nSize','<u4'),
246 ('nDataType','<u4'),
247 ('nSizeOfDataBlock','<u4'),
248 ('nProfilesperBlock','<u4'),
249 ('nDataBlocksperFile','<u4'),
250 ('nNumWindows','<u4'),
251 ('nProcessFlags','<u4'),
252 ('nCoherentIntegrations','<u4'),
253 ('nIncoherentIntegrations','<u4'),
254 ('nTotalSpectra','<u4')
255 ])
256 samplingWindow = 0
257 structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
258 numHeights = 0
259 firstHeight = 0
260 deltaHeight = 0
261 samplesWin = 0
262 spectraComb = 0
263 numCode = 0
264 codes = 0
265 numBaud = 0
266 233
267 234 def __init__(self):
268 pass
235 self.size = 0
236 self.dataType = 0
237 self.blockSize = 0
238 self.profilesPerBlock = 0
239 self.dataBlocksPerFile = 0
240 self.numWindows = 0
241 self.processFlags = 0
242 self.coherentInt = 0
243 self.incoherentInt = 0
244 self.totalSpectra = 0
245 self.struct = numpy.dtype([
246 ('nSize','<u4'),
247 ('nDataType','<u4'),
248 ('nSizeOfDataBlock','<u4'),
249 ('nProfilesperBlock','<u4'),
250 ('nDataBlocksperFile','<u4'),
251 ('nNumWindows','<u4'),
252 ('nProcessFlags','<u4'),
253 ('nCoherentIntegrations','<u4'),
254 ('nIncoherentIntegrations','<u4'),
255 ('nTotalSpectra','<u4')
256 ])
257 self.samplingWindow = 0
258 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
259 self.numHeights = 0
260 self.firstHeight = 0
261 self.deltaHeight = 0
262 self.samplesWin = 0
263 self.spectraComb = 0
264 self.numCode = 0
265 self.codes = 0
266 self.numBaud = 0
269 267
270 268 def read(self, fp):
271 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 24 class VoltageReader(DataReader):
25 25
26 __idFile = None
27
28 __fp = None
29
30 __startDateTime = None
31
32 __endDateTime = None
33
34 __dataType = None
35
36 __fileSizeByHeader = 0
37
38 __pathList = []
39
40 filenameList = []
41
42 __lastUTTime = 0
43
44 __maxTimeStep = 5
45
46 __flagIsNewFile = 0
47
48 __ippSeconds = 0
49
50 flagResetProcessing = 0
51
52 flagIsNewBlock = 0
53
54 noMoreFiles = 0
55
56 nReadBlocks = 0
57
58 online = 0
59
60 filename = None
61
62 fileSize = None
63
64 firstHeaderSize = 0
65
66 basicHeaderSize = 24
67
68 m_BasicHeader = BasicHeader()
69
70 m_SystemHeader = SystemHeader()
71
72 m_RadarControllerHeader = RadarControllerHeader()
73
74 m_ProcessingHeader = ProcessingHeader()
75
76 m_Voltage = None
77
78 __buffer = 0
79
80 __buffer_id = 9999
81
82 26 def __init__(self, m_Voltage = None):
83 27
84 28 if m_Voltage == None:
85 29 m_Voltage = Voltage()
86 30
87 31 self.m_Voltage = m_Voltage
32
33 self.__idFile = None
34
35 self.__fp = None
36
37 self.__startDateTime = None
38
39 self.__endDateTime = None
40
41 self.__dataType = None
42
43 self.__fileSizeByHeader = 0
44
45 self.__pathList = []
46
47 self.filenameList = []
48
49 self.__lastUTTime = 0
50
51 self.__maxTimeStep = 5
52
53 self.__flagIsNewFile = 0
54
55 self.__ippSeconds = 0
56
57 self.flagResetProcessing = 0
58
59 self.flagIsNewBlock = 0
60
61 self.noMoreFiles = 0
62
63 self.nReadBlocks = 0
64
65 self.online = 0
66
67 self.filename = None
68
69 self.fileSize = None
70
71 self.firstHeaderSize = 0
72
73 self.basicHeaderSize = 24
74
75 self.m_BasicHeader = BasicHeader()
76
77 self.m_SystemHeader = SystemHeader()
78
79 self.m_RadarControllerHeader = RadarControllerHeader()
80
81 self.m_ProcessingHeader = ProcessingHeader()
82
83 self.__buffer = 0
84
85 self.__buffer_id = 9999
88 86
89 87 def __rdSystemHeader(self,fp=None):
90 88 if fp == None:
@@ -393,6 +391,7 class VoltageReader(DataReader):
393 391 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
394 392 self.m_Voltage.m_BasicHeader.utc = time
395 393 self.m_Voltage.data = data
394 self.m_Voltage.dataType = self.__dataType
396 395
397 396 self.__buffer_id += 1
398 397
@@ -438,23 +437,190 class VoltageReader(DataReader):
438 437 self.online = online
439 438
440 439 class VoltageWriter(DataWriter):
441
442 m_BasicHeader= BasicHeader()
443
444
445 m_SystemHeader = SystemHeader()
446
447
448 m_RadarControllerHeader = RadarControllerHeader()
449
450
451 m_ProcessingHeader = ProcessingHeader()
452 440
453 m_Voltage = None
454 441
455 def __init__(self, m_Voltage):
442 def __init__(self, m_Voltage = None):
443
444 if m_Voltage == None:
445 m_Voltage = Voltage()
456 446
457 447 self.m_Voltage = m_Voltage
448
449 self.__fp = None
450
451 self.__blocksCounter = 0
452
453 self.__setFile = None
454
455 self.__flagIsNewFile = 0
456
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
458 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
459 592
460 No newline at end of file
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)
619
620
621
622 def __writeBasicHeader(self):
623 pass
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
23 m_ProcessingHeader= ProcessingHeader()
24
25 m_SystemHeader= SystemHeader()
26
27 m_BasicHeader= BasicHeader()
28
29 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
30 data = None
31 21
32 noData = True
33 22
34 23
35 24 def __init__(self):
36 25 '''
37 26 Constructor
38 27 '''
39 pass
28
29 self.m_RadarControllerHeader= RadarControllerHeader()
30
31 self.m_ProcessingHeader= ProcessingHeader()
32
33 self.m_SystemHeader= SystemHeader()
34
35 self.m_BasicHeader= BasicHeader()
36
37 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
38 self.data = None
39
40 self.dataType = None
41
42 self.noData = True
43
44
40 45
41 46 def copy(self):
42 47 obj = Voltage()
General Comments 0
You need to be logged in to leave comments. Login now