##// 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
11 def __init__(self):
10 12 __buffer = 0
11 13 __buffer_count = 0
12 def __init__(self):
13 pass
14 14
15 15 class DataWriter:
16
17 def __init__(self):
16 18 __buffer = 0
17 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 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([
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([
58 59 ('nSize','<u4'),
59 60 ('nVersion','<u2'),
60 61 ('nDataBlockId','<u4'),
@@ -64,8 +65,6 class BasicHeader:
64 65 ('nDstflag','<i2'),
65 66 ('nErrorCount','<u4')
66 67 ])
67
68 def __init__(self):
69 68 pass
70 69
71 70 def read(self, fp):
@@ -97,13 +96,15 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([
99
100 def __init__(self):
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([
107 108 ('nSize','<u4'),
108 109 ('nNumSamples','<u4'),
109 110 ('nNumProfiles','<u4'),
@@ -112,8 +113,6 class SystemHeader:
112 113 ('nPCDIOBusWidth','<u4'),
113 114 ])
114 115
115 def __init__(self):
116 pass
117 116
118 117 def read(self, fp):
119 118 header = numpy.fromfile(fp,self.struct,1)
@@ -141,24 +140,27 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([
143
144
145 def __init__(self):
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([
162 164 ('nSize','<u4'),
163 165 ('nExpType','<u4'),
164 166 ('nNTx','<u4'),
@@ -179,9 +181,6 class RadarControllerHeader:
179 181 ])
180 182
181 183
182 def __init__(self):
183 pass
184
185 184 def read(self, fp):
186 185 header = numpy.fromfile(fp,self.struct,1)
187 186 self.size = header['nSize'][0]
@@ -231,17 +230,19 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([
233
234 def __init__(self):
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([
245 246 ('nSize','<u4'),
246 247 ('nDataType','<u4'),
247 248 ('nSizeOfDataBlock','<u4'),
@@ -253,19 +254,16 class ProcessingHeader:
253 254 ('nIncoherentIntegrations','<u4'),
254 255 ('nTotalSpectra','<u4')
255 256 ])
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
267 def __init__(self):
268 pass
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
26 def __init__(self, m_Voltage = 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:
85 m_Voltage = Voltage()
83 self.__buffer = 0
86 84
87 self.m_Voltage = m_Voltage
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
@@ -439,22 +438,189 class VoltageReader(DataReader):
439 438
440 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 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 46 def copy(self):
42 47 obj = Voltage()
General Comments 0
You need to be logged in to leave comments. Login now