##// END OF EJS Templates
schain-jc
RSS
Modulo de Escritura de Voltage formato Jicamarca.
Daniel Valdez -
r22:3e193d11699b
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,317 +1,402
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author $Author$
4 @author $Author$
5 @version $Id$
5 @version $Id$
6 '''
6 '''
7
7
8 import numpy
8 import numpy
9
9
10 class BasicHeader:
10 class BasicHeader:
11
11
12 def __init__(self):
12 def __init__(self):
13 self.size = 0
13 self.size = 0
14 self.version = 0
14 self.version = 0
15 self.dataBlock = 0
15 self.dataBlock = 0
16 self.utc = 0
16 self.utc = 0
17 self.miliSecond = 0
17 self.miliSecond = 0
18 self.timeZone = 0
18 self.timeZone = 0
19 self.dstFlag = 0
19 self.dstFlag = 0
20 self.errorCount = 0
20 self.errorCount = 0
21 self.struct = numpy.dtype([
21 self.struct = numpy.dtype([
22 ('nSize','<u4'),
22 ('nSize','<u4'),
23 ('nVersion','<u2'),
23 ('nVersion','<u2'),
24 ('nDataBlockId','<u4'),
24 ('nDataBlockId','<u4'),
25 ('nUtime','<u4'),
25 ('nUtime','<u4'),
26 ('nMilsec','<u2'),
26 ('nMilsec','<u2'),
27 ('nTimezone','<i2'),
27 ('nTimezone','<i2'),
28 ('nDstflag','<i2'),
28 ('nDstflag','<i2'),
29 ('nErrorCount','<u4')
29 ('nErrorCount','<u4')
30 ])
30 ])
31 pass
31 pass
32
32
33 def read(self, fp):
33 def read(self, fp):
34
34
35 header = numpy.fromfile(fp, self.struct,1)
35 header = numpy.fromfile(fp, self.struct,1)
36 self.size = header['nSize'][0]
36 self.size = header['nSize'][0]
37 self.version = header['nVersion'][0]
37 self.version = header['nVersion'][0]
38 self.dataBlock = header['nDataBlockId'][0]
38 self.dataBlock = header['nDataBlockId'][0]
39 self.utc = header['nUtime'][0]
39 self.utc = header['nUtime'][0]
40 self.miliSecond = header['nMilsec'][0]
40 self.miliSecond = header['nMilsec'][0]
41 self.timeZone = header['nTimezone'][0]
41 self.timeZone = header['nTimezone'][0]
42 self.dstFlag = header['nDstflag'][0]
42 self.dstFlag = header['nDstflag'][0]
43 self.errorCount = header['nErrorCount'][0]
43 self.errorCount = header['nErrorCount'][0]
44
44
45 return 1
45 return 1
46
46
47 def copy(self):
47 def copy(self):
48
48
49 obj = BasicHeader()
49 obj = BasicHeader()
50 obj.size = self.size
50 obj.size = self.size
51 obj.version = self.version
51 obj.version = self.version
52 obj.dataBlock = self.dataBlock
52 obj.dataBlock = self.dataBlock
53 obj.utc = self.utc
53 obj.utc = self.utc
54 obj.miliSecond = self.miliSecond
54 obj.miliSecond = self.miliSecond
55 obj.timeZone = self.timeZone
55 obj.timeZone = self.timeZone
56 obj.dstFlag = self.dstFlag
56 obj.dstFlag = self.dstFlag
57 obj.errorCount = self.errorCount
57 obj.errorCount = self.errorCount
58
58
59 return obj
59 return obj
60
61 def write(self, fp):
62 headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
63 header = numpy.array(headerTuple,self.struct)
64 header.tofile(fp)
65
66 return 1
60
67
61 class SystemHeader:
68 class SystemHeader:
62
69
63 def __init__(self):
70 def __init__(self):
64 self.size = 0
71 self.size = 0
65 self.numSamples = 0
72 self.numSamples = 0
66 self.numProfiles = 0
73 self.numProfiles = 0
67 self.numChannels = 0
74 self.numChannels = 0
68 self.adcResolution = 0
75 self.adcResolution = 0
69 self.pciDioBusWidth = 0
76 self.pciDioBusWidth = 0
70 self.struct = numpy.dtype([
77 self.struct = numpy.dtype([
71 ('nSize','<u4'),
78 ('nSize','<u4'),
72 ('nNumSamples','<u4'),
79 ('nNumSamples','<u4'),
73 ('nNumProfiles','<u4'),
80 ('nNumProfiles','<u4'),
74 ('nNumChannels','<u4'),
81 ('nNumChannels','<u4'),
75 ('nADCResolution','<u4'),
82 ('nADCResolution','<u4'),
76 ('nPCDIOBusWidth','<u4'),
83 ('nPCDIOBusWidth','<u4'),
77 ])
84 ])
78
85
79
86
80 def read(self, fp):
87 def read(self, fp):
81 header = numpy.fromfile(fp,self.struct,1)
88 header = numpy.fromfile(fp,self.struct,1)
82 self.size = header['nSize'][0]
89 self.size = header['nSize'][0]
83 self.numSamples = header['nNumSamples'][0]
90 self.numSamples = header['nNumSamples'][0]
84 self.numProfiles = header['nNumProfiles'][0]
91 self.numProfiles = header['nNumProfiles'][0]
85 self.numChannels = header['nNumChannels'][0]
92 self.numChannels = header['nNumChannels'][0]
86 self.adcResolution = header['nADCResolution'][0]
93 self.adcResolution = header['nADCResolution'][0]
87 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
94 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
88
95
89
96
90 return 1
97 return 1
91
98
92 def copy(self):
99 def copy(self):
93
100
94 obj = SystemHeader()
101 obj = SystemHeader()
95 obj.size = self.size
102 obj.size = self.size
96 obj.numSamples = self.numSamples
103 obj.numSamples = self.numSamples
97 obj.numProfiles = self.numProfiles
104 obj.numProfiles = self.numProfiles
98 obj.numChannels = self.numChannels
105 obj.numChannels = self.numChannels
99 obj.adcResolution = self.adcResolution
106 obj.adcResolution = self.adcResolution
100 self.pciDioBusWidth = self.pciDioBusWidth
107 self.pciDioBusWidth = self.pciDioBusWidth
101
108
102
109
103 return obj
110 return obj
104
111
112 def write(self, fp):
113 headerTuple = (self.size,self.numSamples,self.numProfiles,self.numChannels,self.adcResolution,self.pciDioBusWidth)
114 header = numpy.array(headerTuple,self.struct)
115 header.tofile(fp)
116
117 return 1
118
105 class RadarControllerHeader:
119 class RadarControllerHeader:
106
120
107
121
108 def __init__(self):
122 def __init__(self):
109 self.size = 0
123 self.size = 0
110 self.expType = 0
124 self.expType = 0
111 self.nTx = 0
125 self.nTx = 0
112 self.ipp = 0
126 self.ipp = 0
113 self.txA = 0
127 self.txA = 0
114 self.txB = 0
128 self.txB = 0
115 self.numWindows = 0
129 self.numWindows = 0
116 self.numTaus = 0
130 self.numTaus = 0
117 self.codeType = 0
131 self.codeType = 0
118 self.line6Function = 0
132 self.line6Function = 0
119 self.line5Fuction = 0
133 self.line5Function = 0
120 self.fClock = 0
134 self.fClock = 0
121 self.prePulseBefore = 0
135 self.prePulseBefore = 0
122 self.prePulserAfter = 0
136 self.prePulserAfter = 0
123 self.rangeIpp = 0
137 self.rangeIpp = 0
124 self.rangeTxA = 0
138 self.rangeTxA = 0
125 self.rangeTxB = 0
139 self.rangeTxB = 0
126 self.struct = numpy.dtype([
140 self.struct = numpy.dtype([
127 ('nSize','<u4'),
141 ('nSize','<u4'),
128 ('nExpType','<u4'),
142 ('nExpType','<u4'),
129 ('nNTx','<u4'),
143 ('nNTx','<u4'),
130 ('fIpp','<f4'),
144 ('fIpp','<f4'),
131 ('fTxA','<f4'),
145 ('fTxA','<f4'),
132 ('fTxB','<f4'),
146 ('fTxB','<f4'),
133 ('nNumWindows','<u4'),
147 ('nNumWindows','<u4'),
134 ('nNumTaus','<u4'),
148 ('nNumTaus','<u4'),
135 ('nCodeType','<u4'),
149 ('nCodeType','<u4'),
136 ('nLine6Function','<u4'),
150 ('nLine6Function','<u4'),
137 ('nLine5Function','<u4'),
151 ('nLine5Function','<u4'),
138 ('fClock','<f4'),
152 ('fClock','<f4'),
139 ('nPrePulseBefore','<u4'),
153 ('nPrePulseBefore','<u4'),
140 ('nPrePulseAfter','<u4'),
154 ('nPrePulseAfter','<u4'),
141 ('sRangeIPP','<a20'),
155 ('sRangeIPP','<a20'),
142 ('sRangeTxA','<a20'),
156 ('sRangeTxA','<a20'),
143 ('sRangeTxB','<a20'),
157 ('sRangeTxB','<a20'),
144 ])
158 ])
159 self.dynamic = numpy.array([],numpy.dtype('byte'))
145
160
146
161
147 def read(self, fp):
162 def read(self, fp):
148 header = numpy.fromfile(fp,self.struct,1)
163 header = numpy.fromfile(fp,self.struct,1)
149 self.size = header['nSize'][0]
164 self.size = header['nSize'][0]
150 self.expType = header['nExpType'][0]
165 self.expType = header['nExpType'][0]
151 self.nTx = header['nNTx'][0]
166 self.nTx = header['nNTx'][0]
152 self.ipp = header['fIpp'][0]
167 self.ipp = header['fIpp'][0]
153 self.txA = header['fTxA'][0]
168 self.txA = header['fTxA'][0]
154 self.txB = header['fTxB'][0]
169 self.txB = header['fTxB'][0]
155 self.numWindows = header['nNumWindows'][0]
170 self.numWindows = header['nNumWindows'][0]
156 self.numTaus = header['nNumTaus'][0]
171 self.numTaus = header['nNumTaus'][0]
157 self.codeType = header['nCodeType'][0]
172 self.codeType = header['nCodeType'][0]
158 self.line6Function = header['nLine6Function'][0]
173 self.line6Function = header['nLine6Function'][0]
159 self.line5Fuction = header['nLine5Function'][0]
174 self.line5Function = header['nLine5Function'][0]
160 self.fClock = header['fClock'][0]
175 self.fClock = header['fClock'][0]
161 self.prePulseBefore = header['nPrePulseBefore'][0]
176 self.prePulseBefore = header['nPrePulseBefore'][0]
162 self.prePulserAfter = header['nPrePulseAfter'][0]
177 self.prePulserAfter = header['nPrePulseAfter'][0]
163 self.rangeIpp = header['sRangeIPP'][0]
178 self.rangeIpp = header['sRangeIPP'][0]
164 self.rangeTxA = header['sRangeTxA'][0]
179 self.rangeTxA = header['sRangeTxA'][0]
165 self.rangeTxB = header['sRangeTxB'][0]
180 self.rangeTxB = header['sRangeTxB'][0]
166 # jump Dynamic Radar Controller Header
181 # jump Dynamic Radar Controller Header
167 jumpHeader = self.size - 116
182 jumpHeader = self.size - 116
168 fp.seek(fp.tell() + jumpHeader)
183 self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpHeader)
169
184
170 return 1
185 return 1
171
186
172 def copy(self):
187 def copy(self):
173
188
174 obj = RadarControllerHeader()
189 obj = RadarControllerHeader()
175 obj.size = self.size
190 obj.size = self.size
176 obj.expType = self.expType
191 obj.expType = self.expType
177 obj.nTx = self.nTx
192 obj.nTx = self.nTx
178 obj.ipp = self.ipp
193 obj.ipp = self.ipp
179 obj.txA = self.txA
194 obj.txA = self.txA
180 obj.txB = self.txB
195 obj.txB = self.txB
181 obj.numWindows = self.numWindows
196 obj.numWindows = self.numWindows
182 obj.numTaus = self.numTaus
197 obj.numTaus = self.numTaus
183 obj.codeType = self.codeType
198 obj.codeType = self.codeType
184 obj.line6Function = self.line6Function
199 obj.line6Function = self.line6Function
185 obj.line5Fuction = self.line5Fuction
200 obj.line5Function = self.line5Function
186 obj.fClock = self.fClock
201 obj.fClock = self.fClock
187 obj.prePulseBefore = self.prePulseBefore
202 obj.prePulseBefore = self.prePulseBefore
188 obj.prePulserAfter = self.prePulserAfter
203 obj.prePulserAfter = self.prePulserAfter
189 obj.rangeIpp = self.rangeIpp
204 obj.rangeIpp = self.rangeIpp
190 obj.rangeTxA = self.rangeTxA
205 obj.rangeTxA = self.rangeTxA
191 obj.rangeTxB = self.rangeTxB
206 obj.rangeTxB = self.rangeTxB
207 obj.dynamic = self.dynamic
192
208
193 return obj
209 return obj
194
210
211 def write(self, fp):
212 headerTuple = (self.size,
213 self.expType,
214 self.nTx,
215 self.ipp,
216 self.txA,
217 self.txB,
218 self.numWindows,
219 self.numTaus,
220 self.codeType,
221 self.line6Function,
222 self.line5Function,
223 self.fClock,
224 self.prePulseBefore,
225 self.prePulserAfter,
226 self.rangeIpp,
227 self.rangeTxA,
228 self.rangeTxB)
229
230 header = numpy.array(headerTuple,self.struct)
231 header.tofile(fp)
232
233 dynamic = self.dynamic
234 dynamic.tofile(fp)
235
236 return 1
237
238
239
195 class ProcessingHeader:
240 class ProcessingHeader:
196
241
197 def __init__(self):
242 def __init__(self):
198 self.size = 0
243 self.size = 0
199 self.dataType = 0
244 self.dataType = 0
200 self.blockSize = 0
245 self.blockSize = 0
201 self.profilesPerBlock = 0
246 self.profilesPerBlock = 0
202 self.dataBlocksPerFile = 0
247 self.dataBlocksPerFile = 0
203 self.numWindows = 0
248 self.numWindows = 0
204 self.processFlags = 0
249 self.processFlags = 0
205 self.coherentInt = 0
250 self.coherentInt = 0
206 self.incoherentInt = 0
251 self.incoherentInt = 0
207 self.totalSpectra = 0
252 self.totalSpectra = 0
208 self.struct = numpy.dtype([
253 self.struct = numpy.dtype([
209 ('nSize','<u4'),
254 ('nSize','<u4'),
210 ('nDataType','<u4'),
255 ('nDataType','<u4'),
211 ('nSizeOfDataBlock','<u4'),
256 ('nSizeOfDataBlock','<u4'),
212 ('nProfilesperBlock','<u4'),
257 ('nProfilesperBlock','<u4'),
213 ('nDataBlocksperFile','<u4'),
258 ('nDataBlocksperFile','<u4'),
214 ('nNumWindows','<u4'),
259 ('nNumWindows','<u4'),
215 ('nProcessFlags','<u4'),
260 ('nProcessFlags','<u4'),
216 ('nCoherentIntegrations','<u4'),
261 ('nCoherentIntegrations','<u4'),
217 ('nIncoherentIntegrations','<u4'),
262 ('nIncoherentIntegrations','<u4'),
218 ('nTotalSpectra','<u4')
263 ('nTotalSpectra','<u4')
219 ])
264 ])
220 self.samplingWindow = 0
265 self.samplingWindow = 0
221 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
266 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
222 self.numHeights = 0
267 self.numHeights = 0
223 self.firstHeight = 0
268 self.firstHeight = 0
224 self.deltaHeight = 0
269 self.deltaHeight = 0
225 self.samplesWin = 0
270 self.samplesWin = 0
226 self.spectraComb = 0
271 self.spectraComb = 0
227 self.numCode = 0
272 self.numCode = 0
228 self.codes = 0
273 self.codes = 0
229 self.numBaud = 0
274 self.numBaud = 0
230
275
231 def read(self, fp):
276 def read(self, fp):
232 header = numpy.fromfile(fp,self.struct,1)
277 header = numpy.fromfile(fp,self.struct,1)
233 self.size = header['nSize'][0]
278 self.size = header['nSize'][0]
234 self.dataType = header['nDataType'][0]
279 self.dataType = header['nDataType'][0]
235 self.blockSize = header['nSizeOfDataBlock'][0]
280 self.blockSize = header['nSizeOfDataBlock'][0]
236 self.profilesPerBlock = header['nProfilesperBlock'][0]
281 self.profilesPerBlock = header['nProfilesperBlock'][0]
237 self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
282 self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
238 self.numWindows = header['nNumWindows'][0]
283 self.numWindows = header['nNumWindows'][0]
239 self.processFlags = header['nProcessFlags']
284 self.processFlags = header['nProcessFlags']
240 self.coherentInt = header['nCoherentIntegrations'][0]
285 self.coherentInt = header['nCoherentIntegrations'][0]
241 self.incoherentInt = header['nIncoherentIntegrations'][0]
286 self.incoherentInt = header['nIncoherentIntegrations'][0]
242 self.totalSpectra = header['nTotalSpectra'][0]
287 self.totalSpectra = header['nTotalSpectra'][0]
243 self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.numWindows)
288 self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.numWindows)
244 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
289 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
245 self.firstHeight = self.samplingWindow['h0']
290 self.firstHeight = self.samplingWindow['h0']
246 self.deltaHeight = self.samplingWindow['dh']
291 self.deltaHeight = self.samplingWindow['dh']
247 self.samplesWin = self.samplingWindow['nsa']
292 self.samplesWin = self.samplingWindow['nsa']
248 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
293 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
249 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
294 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
250 self.numCode = numpy.fromfile(fp,'<u4',1)
295 self.numCode = numpy.fromfile(fp,'<u4',1)
251 self.numBaud = numpy.fromfile(fp,'<u4',1)
296 self.numBaud = numpy.fromfile(fp,'<u4',1)
252 self.codes = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode)
297 self.codes = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode)
253
298
254
299
255 return 1
300 return 1
256
301
257 def copy(self):
302 def copy(self):
258
303
259 obj = ProcessingHeader()
304 obj = ProcessingHeader()
260 obj.size = self.size
305 obj.size = self.size
261 obj.dataType = self.dataType
306 obj.dataType = self.dataType
262 obj.blockSize = self.blockSize
307 obj.blockSize = self.blockSize
263 obj.profilesPerBlock = self.profilesPerBlock
308 obj.profilesPerBlock = self.profilesPerBlock
264 obj.dataBlocksPerFile = self.dataBlocksPerFile
309 obj.dataBlocksPerFile = self.dataBlocksPerFile
265 obj.numWindows = self.numWindows
310 obj.numWindows = self.numWindows
266 obj.processFlags = self.processFlags
311 obj.processFlags = self.processFlags
267 obj.coherentInt = self.coherentInt
312 obj.coherentInt = self.coherentInt
268 obj.incoherentInt = self.incoherentInt
313 obj.incoherentInt = self.incoherentInt
269 obj.totalSpectra = self.totalSpectra
314 obj.totalSpectra = self.totalSpectra
270 obj.samplingWindow = self.samplingWindow
315 obj.samplingWindow = self.samplingWindow
271 obj.numHeights = self.numHeights
316 obj.numHeights = self.numHeights
272 obj.firstHeight = self.firstHeight
317 obj.firstHeight = self.firstHeight
273 obj.deltaHeight = self.deltaHeight
318 obj.deltaHeight = self.deltaHeight
274 obj.samplesWin = self.samplesWin
319 obj.samplesWin = self.samplesWin
275 obj.spectraComb = self.spectraComb
320 obj.spectraComb = self.spectraComb
276 obj.numCode = self.numCode
321 obj.numCode = self.numCode
277 obj.numBaud = self.numBaud
322 obj.numBaud = self.numBaud
278 obj.codes = self.codes
323 obj.codes = self.codes
279
324
280 return obj
325 return obj
326
327 def write(self, fp):
328 headerTuple = (self.size,
329 self.dataType,
330 self.blockSize,
331 self.profilesPerBlock,
332 self.dataBlocksPerFile,
333 self.numWindows,
334 self.processFlags,
335 self.coherentInt,
336 self.incoherentInt,
337 self.totalSpectra)
338
339 header = numpy.array(headerTuple,self.struct)
340 header.tofile(fp)
341
342 if self.numWindows != 0:
343 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
344 samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
345 samplingWindow.tofile(fp)
346
347
348 if self.totalSpectra != 0:
349 spectraComb = numpy.array([],numpy.dtype('u1'))
350 spectraComb = self.spectraComb
351 spectraComb.tofile(fp)
352
353
354 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
355 numCode = self.numCode
356 numCode.tofile(fp)
357
358 numBaud = self.numBaud
359 numBaud.tofile(fp)
360
361 codes = self.codes.reshape(numCode*numBaud)
362 codes.tofile(fp)
363
364 return 1
365
281
366
282 class PROCFLAG:
367 class PROCFLAG:
283 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
368 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
284 DECODE_DATA = numpy.uint32(0x00000002)
369 DECODE_DATA = numpy.uint32(0x00000002)
285 SPECTRA_CALC = numpy.uint32(0x00000004)
370 SPECTRA_CALC = numpy.uint32(0x00000004)
286 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
371 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
287 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
372 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
288 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
373 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
289
374
290 DATATYPE_CHAR = numpy.uint32(0x00000040)
375 DATATYPE_CHAR = numpy.uint32(0x00000040)
291 DATATYPE_SHORT = numpy.uint32(0x00000080)
376 DATATYPE_SHORT = numpy.uint32(0x00000080)
292 DATATYPE_LONG = numpy.uint32(0x00000100)
377 DATATYPE_LONG = numpy.uint32(0x00000100)
293 DATATYPE_INT64 = numpy.uint32(0x00000200)
378 DATATYPE_INT64 = numpy.uint32(0x00000200)
294 DATATYPE_FLOAT = numpy.uint32(0x00000400)
379 DATATYPE_FLOAT = numpy.uint32(0x00000400)
295 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
380 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
296
381
297 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
382 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
298 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
383 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
299 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
384 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
300
385
301 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
386 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
302 DEFLIP_DATA = numpy.uint32(0x00010000)
387 DEFLIP_DATA = numpy.uint32(0x00010000)
303 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
388 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
304
389
305 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
390 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
306 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
391 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
307 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
392 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
308 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
393 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
309 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
394 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
310
395
311 EXP_NAME_ESP = numpy.uint32(0x00200000)
396 EXP_NAME_ESP = numpy.uint32(0x00200000)
312 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
397 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
313
398
314 OPERATION_MASK = numpy.uint32(0x0000003F)
399 OPERATION_MASK = numpy.uint32(0x0000003F)
315 DATATYPE_MASK = numpy.uint32(0x00000FC0)
400 DATATYPE_MASK = numpy.uint32(0x00000FC0)
316 DATAARRANGE_MASK = numpy.uint32(0x00007000)
401 DATAARRANGE_MASK = numpy.uint32(0x00007000)
317 ACQ_SYS_MASK = numpy.uint32(0x001C0000) No newline at end of file
402 ACQ_SYS_MASK = numpy.uint32(0x001C0000)
Show file before | Show file after | Hide comments
@@ -1,50 +1,57
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author $Author$
4 @author $Author$
5 @version $Id$
5 @version $Id$
6 '''
6 '''
7 import os
7 import os
8 import sys
8 import sys
9 import datetime
9 import datetime
10 import time
10 import time
11
11
12 class TestIO():
12 class TestIO():
13
13
14 def __init__(self):
14 def __init__(self):
15 self.setValues()
15 self.setValues()
16 self.createVoltageObjects()
16 self.createVoltageObjects()
17 self.testReadVoltage()
17 self.testReadVoltage()
18 pass
18 pass
19
19
20 def setValues(self):
20 def setValues(self):
21
21
22
22
23 self.path = '/Users/danielangelsuarezmunoz/Documents/Projects'
23 self.path = '/Users/danielangelsuarezmunoz/Documents/Projects/testWR'
24 self.startDateTime = datetime.datetime(2007,5,1,17,49,0)
24 self.startDateTime = datetime.datetime(2007,5,1,17,49,0)
25 self.endDateTime = datetime.datetime(2007,5,1,18,10,0)
25 self.endDateTime = datetime.datetime(2007,5,1,18,15,0)
26
26
27 def createVoltageObjects(self):
27 def createVoltageObjects(self):
28 path = os.path.split(os.getcwd())[0]
28 path = os.path.split(os.getcwd())[0]
29 sys.path.append(path)
29 sys.path.append(path)
30
30
31 from IO.Voltage import VoltageReader
31 from IO.VoltageIO import VoltageReader
32 from IO.VoltageIO import VoltageWriter
32 from Model.Voltage import Voltage
33 from Model.Voltage import Voltage
33
34
34 self.voltageModelObj = Voltage()
35 self.voltageModelObj = Voltage()
35 self.voltageReaderObj = VoltageReader(self.voltageModelObj)
36 self.voltageReaderObj = VoltageReader(self.voltageModelObj)
36 self.voltageReaderObj.setup(self.path, self.startDateTime, self.endDateTime)
37 self.voltageReaderObj.setup(self.path, self.startDateTime, self.endDateTime)
38
39 # self.voltageWriterObj = VoltageWriter(self.voltageModelObj)
40 # self.voltageWriterObj.setup('/Users/danielangelsuarezmunoz/Documents/Projects/testWR')
41
37
42
38 def testReadVoltage(self):
43 def testReadVoltage(self):
39 while(not(self.voltageReaderObj.noMoreFiles)):
44 while(not(self.voltageReaderObj.noMoreFiles)):
40
45
41 self.voltageReaderObj.getData()
46 self.voltageReaderObj.getData()
42 if self.voltageReaderObj.flagResetProcessing:
47 if self.voltageReaderObj.flagResetProcessing:
43 print 'jump'
48 print 'jump'
44
49
45 if self.voltageReaderObj.flagIsNewBlock:
50 if self.voltageReaderObj.flagIsNewBlock:
46 print 'Block No %04d, Time: %s'%(self.voltageReaderObj.nReadBlocks,
51 print 'Block No %04d, Time: %s'%(self.voltageReaderObj.nReadBlocks,
47 datetime.datetime.fromtimestamp(self.voltageReaderObj.m_BasicHeader.utc))
52 datetime.datetime.fromtimestamp(self.voltageReaderObj.m_BasicHeader.utc))
53
54 # self.voltageWriterObj.putData()
48
55
49 if __name__ == '__main__':
56 if __name__ == '__main__':
50 TestIO() No newline at end of file
57 TestIO()
Show file before | Show file after | Hide comments
@@ -1,801 +1,929
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author $Author$
4 @author $Author$
5 @version $Id$
5 @version $Id$
6 '''
6 '''
7
7
8 import os, sys
8 import os, sys
9 import numpy
9 import numpy
10 import glob
10 import glob
11 import fnmatch
11 import fnmatch
12 import time, datetime
12 import time, datetime
13
13
14 path = os.path.split(os.getcwd())[0]
14 path = os.path.split(os.getcwd())[0]
15 sys.path.append(path)
15 sys.path.append(path)
16
16
17 from IO.HeaderIO import *
17 from IO.HeaderIO import *
18 from IO.DataIO import DataReader
18 from IO.DataIO import DataReader
19 from IO.DataIO import DataWriter
19 from IO.DataIO import DataWriter
20
20
21 from Model.Voltage import Voltage
21 from Model.Voltage import Voltage
22
22
23 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
23 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
24 """
24 """
25 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
25 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
26 o no dentro del rango de fecha especificado.
26 o no dentro del rango de fecha especificado.
27
27
28 Inputs:
28 Inputs:
29 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
29 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
30
30
31 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
31 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
32 segundos contados desde 01/01/1970.
32 segundos contados desde 01/01/1970.
33 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
33 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
34 segundos contados desde 01/01/1970.
34 segundos contados desde 01/01/1970.
35
35
36 Return:
36 Return:
37 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
37 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
38 fecha especificado, de lo contrario retorna False.
38 fecha especificado, de lo contrario retorna False.
39
39
40 Excepciones:
40 Excepciones:
41 Si el archivo no existe o no puede ser abierto
41 Si el archivo no existe o no puede ser abierto
42 Si la cabecera no puede ser leida.
42 Si la cabecera no puede ser leida.
43
43
44 """
44 """
45 m_BasicHeader = BasicHeader()
45 m_BasicHeader = BasicHeader()
46
46
47 try:
47 try:
48 fp = open(filename,'rb')
48 fp = open(filename,'rb')
49 except:
49 except:
50 raise IOError, "The file %s can't be opened" %(filename)
50 raise IOError, "The file %s can't be opened" %(filename)
51
51
52 if not(m_BasicHeader.read(fp)):
52 if not(m_BasicHeader.read(fp)):
53 raise IOError, "The file %s has not a valid header" %(filename)
53 raise IOError, "The file %s has not a valid header" %(filename)
54
54
55 fp.close()
55 fp.close()
56
56
57 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
57 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
58 return 0
58 return 0
59
59
60 return 1
60 return 1
61
61
62 class VoltageReader(DataReader):
62 class VoltageReader(DataReader):
63 """
63 """
64 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
64 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
65 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
65 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
66 perfiles*alturas*canales) son almacenados en la variable "buffer".
66 perfiles*alturas*canales) son almacenados en la variable "buffer".
67
67
68 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
68 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
69 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
69 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
70 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
70 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
71 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
71 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
72
72
73 Example:
73 Example:
74
74
75 dpath = "/home/myuser/data"
75 dpath = "/home/myuser/data"
76
76
77 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
77 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
78
78
79 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
79 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
80
80
81 readerObj = VoltageReader()
81 readerObj = VoltageReader()
82
82
83 readerObj.setup(dpath, startTime, endTime)
83 readerObj.setup(dpath, startTime, endTime)
84
84
85 while(True):
85 while(True):
86
86
87 readerObj.getData()
87 readerObj.getData()
88
88
89 print readerObj.m_Voltage.data
89 print readerObj.m_Voltage.data
90
90
91 if readerObj.noMoreFiles:
91 if readerObj.noMoreFiles:
92 break
92 break
93
93
94 """
94 """
95
95
96 #speed of light
96 #speed of light
97 __c = 3E8
97 __c = 3E8
98
98
99 def __init__(self, m_Voltage = None):
99 def __init__(self, m_Voltage = None):
100 """
100 """
101 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
101 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
102
102
103 Input:
103 Input:
104 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
104 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
105 almacenar un perfil de datos cada vez que se haga un requerimiento
105 almacenar un perfil de datos cada vez que se haga un requerimiento
106 (getData). El perfil sera obtenido a partir del buffer de datos,
106 (getData). El perfil sera obtenido a partir del buffer de datos,
107 si el buffer esta vacio se hara un nuevo proceso de lectura de un
107 si el buffer esta vacio se hara un nuevo proceso de lectura de un
108 bloque de datos.
108 bloque de datos.
109 Si este parametro no es pasado se creara uno internamente.
109 Si este parametro no es pasado se creara uno internamente.
110
110
111 Variables afectadas:
111 Variables afectadas:
112 self.m_Voltage
112 self.m_Voltage
113 self.m_BasicHeader
113 self.m_BasicHeader
114 self.m_SystemHeader
114 self.m_SystemHeader
115 self.m_RadarControllerHeader
115 self.m_RadarControllerHeader
116 self.m_ProcessingHeader
116 self.m_ProcessingHeader
117
117
118
118
119 Return:
119 Return:
120 Void
120 Void
121
121
122 """
122 """
123 if m_Voltage == None:
123 if m_Voltage == None:
124 m_Voltage = Voltage()
124 m_Voltage = Voltage()
125
125
126 if not(isinstance(m_Voltage, Voltage)):
126 if not(isinstance(m_Voltage, Voltage)):
127 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
127 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
128
128
129 self.m_Voltage = m_Voltage
129 self.m_Voltage = m_Voltage
130
130
131 self.m_BasicHeader = BasicHeader()
131 self.m_BasicHeader = BasicHeader()
132
132
133 self.m_SystemHeader = SystemHeader()
133 self.m_SystemHeader = SystemHeader()
134
134
135 self.m_RadarControllerHeader = RadarControllerHeader()
135 self.m_RadarControllerHeader = RadarControllerHeader()
136
136
137 self.m_ProcessingHeader = ProcessingHeader()
137 self.m_ProcessingHeader = ProcessingHeader()
138
138
139 self.__fp = None
139 self.__fp = None
140
140
141 self.__idFile = None
141 self.__idFile = None
142
142
143 self.__startDateTime = None
143 self.__startDateTime = None
144
144
145 self.__endDateTime = None
145 self.__endDateTime = None
146
146
147 self.__dataType = None
147 self.__dataType = None
148
148
149 self.__fileSizeByHeader = 0
149 self.__fileSizeByHeader = 0
150
150
151 self.__pathList = []
151 self.__pathList = []
152
152
153 self.filenameList = []
153 self.filenameList = []
154
154
155 self.__lastUTTime = 0
155 self.__lastUTTime = 0
156
156
157 self.__maxTimeStep = 30
157 self.__maxTimeStep = 30
158
158
159 self.__flagIsNewFile = 0
159 self.__flagIsNewFile = 0
160
160
161 self.__ippSeconds = 0
161 self.__ippSeconds = 0
162
162
163 self.flagResetProcessing = 0
163 self.flagResetProcessing = 0
164
164
165 self.flagIsNewBlock = 0
165 self.flagIsNewBlock = 0
166
166
167 self.noMoreFiles = 0
167 self.noMoreFiles = 0
168
168
169 self.nReadBlocks = 0
169 self.nReadBlocks = 0
170
170
171 self.online = 0
171 self.online = 0
172
172
173 self.filename = None
173 self.filename = None
174
174
175 self.fileSize = None
175 self.fileSize = None
176
176
177 self.firstHeaderSize = 0
177 self.firstHeaderSize = 0
178
178
179 self.basicHeaderSize = 24
179 self.basicHeaderSize = 24
180
180
181 self.idProfile = 0
181 self.idProfile = 0
182
182
183 self.__buffer = 0
183 self.__buffer = 0
184
184
185 self.__buffer_id = 9999
185 self.__buffer_id = 9999
186
186
187 def __rdSystemHeader(self,fp=None):
187 def __rdSystemHeader(self,fp=None):
188 if fp == None:
188 if fp == None:
189 fp = self.__fp
189 fp = self.__fp
190
190
191 self.m_SystemHeader.read(fp)
191 self.m_SystemHeader.read(fp)
192
192
193 def __rdRadarControllerHeader(self,fp=None):
193 def __rdRadarControllerHeader(self,fp=None):
194 if fp == None:
194 if fp == None:
195 fp = self.__fp
195 fp = self.__fp
196
196
197 self.m_RadarControllerHeader.read(fp)
197 self.m_RadarControllerHeader.read(fp)
198
198
199 def __rdProcessingHeader(self,fp=None):
199 def __rdProcessingHeader(self,fp=None):
200 if fp == None:
200 if fp == None:
201 fp = self.__fp
201 fp = self.__fp
202
202
203 self.m_ProcessingHeader.read(fp)
203 self.m_ProcessingHeader.read(fp)
204
204
205 def __rdBasicHeader(self, fp=None):
205 def __rdBasicHeader(self, fp=None):
206
206
207 if fp == None:
207 if fp == None:
208 fp = self.__fp
208 fp = self.__fp
209
209
210 self.m_BasicHeader.read(fp)
210 self.m_BasicHeader.read(fp)
211
211
212 def __readFirstHeader(self):
212 def __readFirstHeader(self):
213
213
214 self.__rdBasicHeader()
214 self.__rdBasicHeader()
215 self.__rdSystemHeader()
215 self.__rdSystemHeader()
216 self.__rdRadarControllerHeader()
216 self.__rdRadarControllerHeader()
217 self.__rdProcessingHeader()
217 self.__rdProcessingHeader()
218 self.firstHeaderSize = self.m_BasicHeader.size
218 self.firstHeaderSize = self.m_BasicHeader.size
219
219
220 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
220 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
221 if data_type == 0:
221 if data_type == 0:
222 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
222 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
223
223
224 elif data_type == 1:
224 elif data_type == 1:
225 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
225 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
226
226
227 elif data_type == 2:
227 elif data_type == 2:
228 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
228 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
229
229
230 elif data_type == 3:
230 elif data_type == 3:
231 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
231 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
232
232
233 elif data_type == 4:
233 elif data_type == 4:
234 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
234 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
235
235
236 elif data_type == 5:
236 elif data_type == 5:
237 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
237 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
238
238
239 else:
239 else:
240 raise ValueError, 'Data type was not defined'
240 raise ValueError, 'Data type was not defined'
241
241
242 xi = self.m_ProcessingHeader.firstHeight
242 xi = self.m_ProcessingHeader.firstHeight
243 step = self.m_ProcessingHeader.deltaHeight
243 step = self.m_ProcessingHeader.deltaHeight
244 xf = xi + self.m_ProcessingHeader.numHeights*step
244 xf = xi + self.m_ProcessingHeader.numHeights*step
245
245
246 self.__heights = numpy.arange(xi, xf, step)
246 self.__heights = numpy.arange(xi, xf, step)
247 self.__dataType = tmp
247 self.__dataType = tmp
248 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
248 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
249 self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/self.__c
249 self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/self.__c
250
250
251 def __setNextFileOnline(self):
251 def __setNextFileOnline(self):
252 return 0
252 return 0
253
253
254 def __setNextFileOffline(self):
254 def __setNextFileOffline(self):
255
255
256 idFile = self.__idFile
256 idFile = self.__idFile
257 while(True):
257 while(True):
258
258
259 idFile += 1
259 idFile += 1
260
260
261 if not(idFile < len(self.filenameList)):
261 if not(idFile < len(self.filenameList)):
262 self.noMoreFiles = 1
262 self.noMoreFiles = 1
263 return 0
263 return 0
264
264
265 filename = self.filenameList[idFile]
265 filename = self.filenameList[idFile]
266 fileSize = os.path.getsize(filename)
266 fileSize = os.path.getsize(filename)
267
267
268 try:
268 try:
269 fp = open(filename,'rb')
269 fp = open(filename,'rb')
270 except:
270 except:
271 raise IOError, "The file %s can't be opened" %filename
271 raise IOError, "The file %s can't be opened" %filename
272
272
273 currentSize = fileSize - fp.tell()
273 currentSize = fileSize - fp.tell()
274 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
274 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
275
275
276 if (currentSize < neededSize):
276 if (currentSize < neededSize):
277 print "Skipping the file %s due to it hasn't enough data" %filename
277 print "Skipping the file %s due to it hasn't enough data" %filename
278 continue
278 continue
279
279
280 break
280 break
281
281
282 self.__flagIsNewFile = 1
282 self.__flagIsNewFile = 1
283 self.__idFile = idFile
283 self.__idFile = idFile
284 self.filename = filename
284 self.filename = filename
285 self.fileSize = fileSize
285 self.fileSize = fileSize
286 self.__fp = fp
286 self.__fp = fp
287
287
288 print 'Setting the file: %s'%self.filename
288 print 'Setting the file: %s'%self.filename
289
289
290 return 1
290 return 1
291
291
292 def __setNextFile(self):
292 def __setNextFile(self):
293
293
294 if self.online:
294 if self.online:
295 newFile = self.__setNextFileOnline()
295 newFile = self.__setNextFileOnline()
296 else:
296 else:
297 newFile = self.__setNextFileOffline()
297 newFile = self.__setNextFileOffline()
298
298
299 if not(newFile):
299 if not(newFile):
300 return 0
300 return 0
301
301
302 self.__readFirstHeader()
302 self.__readFirstHeader()
303
303
304 return 1
304 return 1
305
305
306 def __setNewBlock(self):
306 def __setNewBlock(self):
307
307
308 if self.__fp == None:
308 if self.__fp == None:
309 return 0
309 return 0
310
310
311 if self.__flagIsNewFile:
311 if self.__flagIsNewFile:
312 return 1
312 return 1
313
313
314 currentSize = self.fileSize - self.__fp.tell()
314 currentSize = self.fileSize - self.__fp.tell()
315 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
315 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
316
316
317 #If there is enough data setting new data block
317 #If there is enough data setting new data block
318 if (currentSize >= neededSize):
318 if (currentSize >= neededSize):
319 self.__rdBasicHeader()
319 self.__rdBasicHeader()
320 return 1
320 return 1
321
321
322 #Setting new file
322 #Setting new file
323 if not(self.__setNextFile()):
323 if not(self.__setNextFile()):
324 return 0
324 return 0
325
325
326 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
326 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
327
327
328 self.flagResetProcessing = 0
328 self.flagResetProcessing = 0
329
329
330 if deltaTime > self.__maxTimeStep:
330 if deltaTime > self.__maxTimeStep:
331 self.flagResetProcessing = 1
331 self.flagResetProcessing = 1
332 self.nReadBlocks = 0
332 self.nReadBlocks = 0
333
333
334 return 1
334 return 1
335
335
336 def __readBlock(self):
336 def __readBlock(self):
337 """
337 """
338 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
338 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
339 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
339 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
340 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
340 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
341 es seteado a 0
341 es seteado a 0
342
342
343
343
344 Inputs:
344 Inputs:
345 None
345 None
346
346
347 Return:
347 Return:
348 None
348 None
349
349
350 Variables afectadas:
350 Variables afectadas:
351
351
352 self.__buffer_id
352 self.__buffer_id
353
353
354 self.__buffer
354 self.__buffer
355
355
356 self.__flagIsNewFile
356 self.__flagIsNewFile
357
357
358 self.idProfile
358 self.idProfile
359
359
360 self.flagIsNewBlock
360 self.flagIsNewBlock
361
361
362 self.nReadBlocks
362 self.nReadBlocks
363
363
364 """
364 """
365
365
366 pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
366 pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
367
367
368 junk = numpy.fromfile(self.__fp, self.__dataType, pts2read)
368 junk = numpy.fromfile(self.__fp, self.__dataType, pts2read)
369
369
370 junk = junk.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels))
370 junk = junk.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels))
371
371
372 data = junk['real'] + junk['imag']*1j
372 data = junk['real'] + junk['imag']*1j
373
373
374 self.__buffer_id = 0
374 self.__buffer_id = 0
375
375
376 self.__buffer = data
376 self.__buffer = data
377
377
378 self.__flagIsNewFile = 0
378 self.__flagIsNewFile = 0
379
379
380 self.idProfile = 0
380 self.idProfile = 0
381
381
382 self.flagIsNewBlock = 1
382 self.flagIsNewBlock = 1
383
383
384 self.nReadBlocks += 1
384 self.nReadBlocks += 1
385
385
386 def __hasNotDataInBuffer(self):
386 def __hasNotDataInBuffer(self):
387 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
387 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
388 return 1
388 return 1
389
389
390 return 0
390 return 0
391
391
392 def __searchFiles(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
392 def __searchFiles(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
393 """
393 """
394 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
394 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
395 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
395 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
396 correcta la estructura de directorios debe ser la siguiente:
396 correcta la estructura de directorios debe ser la siguiente:
397
397
398 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
398 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
399
399
400 [yyyy]: anio
400 [yyyy]: anio
401 [ddd] : dia del anio
401 [ddd] : dia del anio
402 [sss] : set del archivo
402 [sss] : set del archivo
403
403
404 Inputs:
404 Inputs:
405 path : Directorio de datos donde se realizara la busqueda. Todos los
405 path : Directorio de datos donde se realizara la busqueda. Todos los
406 ficheros que concidan con el criterio de busqueda seran
406 ficheros que concidan con el criterio de busqueda seran
407 almacenados en una lista y luego retornados.
407 almacenados en una lista y luego retornados.
408 startDateTime : Fecha inicial. Rechaza todos los archivos donde
408 startDateTime : Fecha inicial. Rechaza todos los archivos donde
409 file end time < startDateTime (obejto datetime.datetime)
409 file end time < startDateTime (obejto datetime.datetime)
410
410
411 endDateTime : Fecha final. Rechaza todos los archivos donde
411 endDateTime : Fecha final. Rechaza todos los archivos donde
412 file start time > endDateTime (obejto datetime.datetime)
412 file start time > endDateTime (obejto datetime.datetime)
413
413
414 set : Set del primer archivo a leer. Por defecto None
414 set : Set del primer archivo a leer. Por defecto None
415
415
416 expLabel : Nombre del subdirectorio de datos. Por defecto ""
416 expLabel : Nombre del subdirectorio de datos. Por defecto ""
417
417
418 ext : Extension de los archivos a leer. Por defecto .r
418 ext : Extension de los archivos a leer. Por defecto .r
419
419
420 Return:
420 Return:
421
421
422 (pathList, filenameList)
422 (pathList, filenameList)
423
423
424 pathList : Lista de directorios donde se encontraron archivos dentro
424 pathList : Lista de directorios donde se encontraron archivos dentro
425 de los parametros especificados
425 de los parametros especificados
426 filenameList : Lista de archivos (ruta completa) que coincidieron con los
426 filenameList : Lista de archivos (ruta completa) que coincidieron con los
427 parametros especificados.
427 parametros especificados.
428
428
429 Variables afectadas:
429 Variables afectadas:
430
430
431 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
431 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
432 como fuente para leer los bloque de datos, si se termina
432 como fuente para leer los bloque de datos, si se termina
433 de leer todos los bloques de datos de un determinado
433 de leer todos los bloques de datos de un determinado
434 archivo se pasa al siguiente archivo de la lista.
434 archivo se pasa al siguiente archivo de la lista.
435
435
436 Excepciones:
436 Excepciones:
437
437
438 """
438 """
439
439
440 print "Searching files ..."
440 print "Searching files ..."
441
441
442 dirList = []
442 dirList = []
443 for thisPath in os.listdir(path):
443 for thisPath in os.listdir(path):
444 if os.path.isdir(os.path.join(path,thisPath)):
444 if os.path.isdir(os.path.join(path,thisPath)):
445 dirList.append(thisPath)
445 dirList.append(thisPath)
446
446
447 pathList = []
447 pathList = []
448
448
449 thisDateTime = startDateTime
449 thisDateTime = startDateTime
450
450
451 while(thisDateTime <= endDateTime):
451 while(thisDateTime <= endDateTime):
452 year = thisDateTime.timetuple().tm_year
452 year = thisDateTime.timetuple().tm_year
453 doy = thisDateTime.timetuple().tm_yday
453 doy = thisDateTime.timetuple().tm_yday
454
454
455 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
455 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
456 if len(match) == 0:
456 if len(match) == 0:
457 thisDateTime += datetime.timedelta(1)
457 thisDateTime += datetime.timedelta(1)
458 continue
458 continue
459
459
460 pathList.append(os.path.join(path,match[0],expLabel))
460 pathList.append(os.path.join(path,match[0],expLabel))
461 thisDateTime += datetime.timedelta(1)
461 thisDateTime += datetime.timedelta(1)
462
462
463 startUtSeconds = time.mktime(startDateTime.timetuple())
463 startUtSeconds = time.mktime(startDateTime.timetuple())
464 endUtSeconds = time.mktime(endDateTime.timetuple())
464 endUtSeconds = time.mktime(endDateTime.timetuple())
465
465
466 filenameList = []
466 filenameList = []
467 for thisPath in pathList:
467 for thisPath in pathList:
468 fileList = glob.glob1(thisPath, "*%s" %ext)
468 fileList = glob.glob1(thisPath, "*%s" %ext)
469 fileList.sort()
469 fileList.sort()
470 for file in fileList:
470 for file in fileList:
471 filename = os.path.join(thisPath,file)
471 filename = os.path.join(thisPath,file)
472 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
472 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
473 filenameList.append(filename)
473 filenameList.append(filename)
474
474
475 self.filenameList = filenameList
475 self.filenameList = filenameList
476
476
477 return pathList, filenameList
477 return pathList, filenameList
478
478
479 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0):
479 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0):
480 """
480 """
481 setup configura los parametros de lectura de la clase VoltageReader.
481 setup configura los parametros de lectura de la clase VoltageReader.
482
482
483 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
483 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
484 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
484 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
485 self.filenameList.
485 self.filenameList.
486
486
487 Input:
487 Input:
488 path : Directorios donde se ubican los datos a leer. Dentro de este
488 path : Directorios donde se ubican los datos a leer. Dentro de este
489 directorio deberia de estar subdirectorios de la forma:
489 directorio deberia de estar subdirectorios de la forma:
490
490
491 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
491 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
492
492
493 startDateTime : Fecha inicial. Rechaza todos los archivos donde
493 startDateTime : Fecha inicial. Rechaza todos los archivos donde
494 file end time < startDatetime (obejto datetime.datetime)
494 file end time < startDatetime (obejto datetime.datetime)
495
495
496 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
496 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
497 file end time < startDatetime (obejto datetime.datetime)
497 file end time < startDatetime (obejto datetime.datetime)
498
498
499 set : Set del primer archivo a leer. Por defecto None
499 set : Set del primer archivo a leer. Por defecto None
500
500
501 expLabel : Nombre del subdirectorio de datos. Por defecto ""
501 expLabel : Nombre del subdirectorio de datos. Por defecto ""
502
502
503 ext : Extension de los archivos a leer. Por defecto .r
503 ext : Extension de los archivos a leer. Por defecto .r
504
504
505 online :
505 online :
506
506
507 Return:
507 Return:
508
508
509 Affected:
509 Affected:
510
510
511 Excepciones:
511 Excepciones:
512
512
513 Example:
513 Example:
514
514
515 """
515 """
516
516
517 if online == 0:
517 if online == 0:
518 pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext)
518 pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext)
519
519
520 self.__idFile = -1
520 self.__idFile = -1
521
521
522 if not(self.__setNextFile()):
522 if not(self.__setNextFile()):
523 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
523 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
524 return 0
524 return 0
525
525
526 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
526 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
527 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
527 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
528
528
529 self.startYear = startDateTime.timetuple().tm_year
529 self.startYear = startDateTime.timetuple().tm_year
530 self.endYear = endDateTime.timetuple().tm_year
530 self.endYear = endDateTime.timetuple().tm_year
531
531
532 self.startDoy = startDateTime.timetuple().tm_yday
532 self.startDoy = startDateTime.timetuple().tm_yday
533 self.endDoy = endDateTime.timetuple().tm_yday
533 self.endDoy = endDateTime.timetuple().tm_yday
534 #call fillHeaderValues() - to Data Object
534
535 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
536 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
537 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
538 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
539 self.m_Voltage.dataType = self.__dataType
535
540
536 self.__pathList = pathList
541 self.__pathList = pathList
537 self.filenameList = filenameList
542 self.filenameList = filenameList
538 self.online = online
543 self.online = online
539
544
540 def readNextBlock(self):
545 def readNextBlock(self):
541 """
546 """
542 readNextBlock establece un nuevo bloque de datos a leer y los lee, si es que no existiese
547 readNextBlock establece un nuevo bloque de datos a leer y los lee, si es que no existiese
543 mas bloques disponibles en el archivo actual salta al siguiente.
548 mas bloques disponibles en el archivo actual salta al siguiente.
544
549
545 """
550 """
546
551
547 if not(self.__setNewBlock()):
552 if not(self.__setNewBlock()):
548 return 0
553 return 0
549
554
550 self.__readBlock()
555 self.__readBlock()
551
556
552 self.__lastUTTime = self.m_BasicHeader.utc
557 self.__lastUTTime = self.m_BasicHeader.utc
553
558
554 return 1
559 return 1
555
560
556 def getData(self):
561 def getData(self):
557 """
562 """
558 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
563 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
559 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
564 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
560 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
565 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
561
566
562 Ademas incrementa el contador del buffer en 1.
567 Ademas incrementa el contador del buffer en 1.
563
568
564 Inputs:
569 Inputs:
565 None
570 None
566
571
567 Return:
572 Return:
568 data : retorna un perfil de voltages (alturas * canales) copiados desde el
573 data : retorna un perfil de voltages (alturas * canales) copiados desde el
569 buffer. Si no hay mas archivos a leer retorna None.
574 buffer. Si no hay mas archivos a leer retorna None.
570
575
571 Variables afectadas:
576 Variables afectadas:
572 self.m_Voltage
577 self.m_Voltage
573 self.__buffer_id
578 self.__buffer_id
574 self.idProfile
579 self.idProfile
575
580
576 Excepciones:
581 Excepciones:
577
582
578 """
583 """
579 self.flagResetProcessing = 0
584 self.flagResetProcessing = 0
580 self.flagIsNewBlock = 0
585 self.flagIsNewBlock = 0
581
586
582 if self.__hasNotDataInBuffer():
587 if self.__hasNotDataInBuffer():
583 self.readNextBlock()
588 self.readNextBlock()
584
589
585 if self.noMoreFiles == 1:
590 if self.noMoreFiles == 1:
586 print 'Process finished'
591 print 'Process finished'
587 return None
592 return None
588
593
589 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
594 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
590 data = self.__buffer[self.__buffer_id,:,:]
595 data = self.__buffer[self.__buffer_id,:,:]
591
596
592 time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
597 time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
593
598
594 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
599 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
595 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
600 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
596 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
601 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
597 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
602 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
598 self.m_Voltage.m_BasicHeader.utc = time
603 self.m_Voltage.m_BasicHeader.utc = time
599 self.m_Voltage.data = data
604 self.m_Voltage.data = data
605 self.m_Voltage.flagNoData = False
606 self.m_Voltage.flagResetProcessing = self.flagResetProcessing
600 self.m_Voltage.heights = self.__heights
607 self.m_Voltage.heights = self.__heights
601 self.m_Voltage.idProfile = self.idProfile
608 self.m_Voltage.idProfile = self.idProfile
602 self.m_Voltage.dataType = self.__dataType
609 self.m_Voltage.dataType = self.__dataType
603
610
604 self.__buffer_id += 1
611 self.__buffer_id += 1
605 self.idProfile += 1
612 self.idProfile += 1
606
613
607 #call setData - to Data Object
614 #call setData - to Data Object
608
615
609 return data
616 return data
610
617
611
612
613
614 class VoltageWriter(DataWriter):
618 class VoltageWriter(DataWriter):
615
619 __configHeaderFile = 'wrSetHeadet.txt'
616
620
617 def __init__(self, m_Voltage = None):
621 def __init__(self, m_Voltage = None):
618
622
619 if m_Voltage == None:
623 if m_Voltage == None:
620 m_Voltage = Voltage()
624 m_Voltage = Voltage()
621
625
622 self.m_Voltage = m_Voltage
626 self.m_Voltage = m_Voltage
623
627
628 self.__path = None
629
624 self.__fp = None
630 self.__fp = None
631
632 self.__format = None
625
633
626 self.__blocksCounter = 0
634 self.__blocksCounter = 0
627
635
628 self.__setFile = None
636 self.__setFile = None
629
637
630 self.__flagIsNewFile = 0
638 self.__flagIsNewFile = 1
631
639
632 self.__buffer = 0
640 self.__buffer = 0
633
641
634 self.__buffer_id = 0
642 self.__buffer_id = 0
635
643
636 self.__dataType = None
644 self.__dataType = None
637
645
638 self.__ext = None
646 self.__ext = None
639
647
640 self.nWriteBlocks = 0
648 self.nWriteBlocks = 0
641
649
642 self.flagIsNewBlock = 0
650 self.flagIsNewBlock = 0
643
651
644 self.noMoreFiles = 0
652 self.noMoreFiles = 0
645
653
646 self.filename = None
654 self.filename = None
647
655
648 self.m_BasicHeader= BasicHeader()
656 self.m_BasicHeader= BasicHeader()
649
657
650 self.m_SystemHeader = SystemHeader()
658 self.m_SystemHeader = SystemHeader()
651
659
652 self.m_RadarControllerHeader = RadarControllerHeader()
660 self.m_RadarControllerHeader = RadarControllerHeader()
653
661
654 self.m_ProcessingHeader = ProcessingHeader()
662 self.m_ProcessingHeader = ProcessingHeader()
655
663
664
665 def __writeBasicHeader(self, fp=None):
666 if fp == None:
667 fp = self.__fp
668
669 self.m_BasicHeader.write(fp)
670
671 def __wrSystemHeader(self,fp=None):
672 if fp == None:
673 fp = self.__fp
674
675 self.m_SystemHeader.write(fp)
676
677 def __wrRadarControllerHeader(self,fp=None):
678 if fp == None:
679 fp = self.__fp
680
681 self.m_RadarControllerHeader.write(fp)
682
683 def __wrProcessingHeader(self,fp=None):
684 if fp == None:
685 fp = self.__fp
686
687 self.m_ProcessingHeader.write(fp)
688
689 def __writeFirstHeader(self):
690 self.__writeBasicHeader()
691 self.__wrSystemHeader()
692 self.__wrRadarControllerHeader()
693 self.__wrProcessingHeader()
694 self.__dataType = self.m_Voltage.dataType
695
696
656 def __setNextFile(self):
697 def __setNextFile(self):
698
657 setFile = self.__setFile
699 setFile = self.__setFile
658 ext = self.__ext
700 ext = self.__ext
659 path = self.__path
701 path = self.__path
660
702
661 setFile += 1
703 setFile += 1
662
704
663 if not(self.__blocksCounter >= self.m_ProcessingHeader.dataBlocksPerFile):
705 if self.__fp != None:
664 self.__fp.close()
706 self.__fp.close()
665 return 0
666
707
667 timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
708 timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
668 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_doy,setFile,ext)
709 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext)
669 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_doy)
710 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
670 tmp = os.path.join(path,subfolder)
711 tmp = os.path.join(path,subfolder)
671 if not(os.path.exists(tmp)):
712 if not(os.path.exists(tmp)):
672 os.mkdir(tmp)
713 os.mkdir(tmp)
673
714
674 filename = os.path.join(path,subfolder,file)
715 filename = os.path.join(path,subfolder,file)
675 fp = open(filename,'wb')
716 fp = open(filename,'wb')
676
717
677
718 self.__blocksCounter = 0
678
719
679 #guardando atributos
720 #guardando atributos
680 self.filename = filename
721 self.filename = filename
681 self.__subfolder = subfolder
722 self.__subfolder = subfolder
682 self.__fp = fp
723 self.__fp = fp
683 self.__setFile = setFile
724 self.__setFile = setFile
684 self.__flagIsNewFile = 1
725 self.__flagIsNewFile = 1
685
726
686 print 'Writing the file: %s'%self.filename
727 print 'Writing the file: %s'%self.filename
687
728
729 self.__writeFirstHeader()
730
688 return 1
731 return 1
689
690
691
732
692 def __setNewBlock(self):
733 def __setNewBlock(self):
693 if self.__fp == None:
734 if self.__fp == None:
694 return 0
735 return 0
695
736
696 if self.__flagIsNewFile:
737 if self.__flagIsNewFile:
697 return 1
738 return 1
698
739
699 #Bloques completados?
740 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
700 if self.__blocksCounter < self.m_ProcessingHeader.profilesPerBlock:
701 self.__writeBasicHeader()
741 self.__writeBasicHeader()
702 return 1
742 return 1
703
743
704 if not(self.__setNextFile()):
744 if not(self.__setNextFile()):
705 return 0
745 return 0
706
746
707 self.__writeFirstHeader()
708
709 return 1
747 return 1
710
748
711 def __writeBlock(self):
749 def __writeBlock(self):
712
750
713 numpy.save(self.__fp,self.__buffer)
751 self.__buffer.tofile(self.__fp)
714
752
715 self.__buffer = numpy.array([],self.__dataType)
753 self.__buffer = numpy.array([],self.__dataType)
716
754
717 self.__buffer_id = 0
755 self.__buffer_id = 0
718
756
719 self.__flagIsNewFile = 0
757 self.__flagIsNewFile = 0
720
758
721 self.flagIsNewBlock = 1
759 self.flagIsNewBlock = 1
722
760
723 self.nWriteBlocks += 1
761 self.nWriteBlocks += 1
724
762
725 self.__blocksCounter += 1
763 self.__blocksCounter += 1
726
764
765
727 def writeNextBlock(self):
766 def writeNextBlock(self):
767
728 if not(self.__setNewBlock()):
768 if not(self.__setNewBlock()):
729 return 0
769 return 0
730
770
731 self.__writeBlock()
771 self.__writeBlock()
732
772
733 return 1
773 return 1
734
774
735 def __hasAllDataInBuffer(self):
775 def __hasAllDataInBuffer(self):
736 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
776 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
737 return 1
777 return 1
738
778
739 return 0
779 return 0
740
780
741 def putData(self):
781 def putData(self):
742 self.flagIsNewBlock = 0
782 self.flagIsNewBlock = 0
743
783
744 if self.m_Voltage.noData:
784 if self.m_Voltage.flagNoData:
745 return None
785 return None
746
786
747 shape = self.m_Voltage.data.shape
787 if self.m_Voltage.flagResetProcessing:
788 self.__buffer = numpy.array([],self.__dataType)
789 self.__buffer_id = 0
790 self.__setNextFile()
791
792 self.__setHeaderByObj()
793
794 shape = self.m_Voltage.data.shape
748 data = numpy.zeros(shape,self.__dataType)
795 data = numpy.zeros(shape,self.__dataType)
796
749 data['real'] = self.m_Voltage.data.real
797 data['real'] = self.m_Voltage.data.real
750 data['imag'] = self.m_Voltage.data.imag
798 data['imag'] = self.m_Voltage.data.imag
799
751 data = data.reshape((-1))
800 data = data.reshape((-1))
752
801
753 self.__buffer = numpy.hstack((self.__buffer,data))
802 self.__buffer = numpy.hstack((self.__buffer,data))
754
803
755 self.__buffer_id += 1
804 self.__buffer_id += 1
756
805
757 if __hasAllDataInBuffer():
806 if self.__hasAllDataInBuffer():
758 self.writeNextBlock()
807 self.writeNextBlock()
759
808
760
809
761 if self.noMoreFiles:
810 if self.noMoreFiles:
762 print 'Process finished'
811 print 'Process finished'
763 return None
812 return None
764
813
765 return 1
814 return 1
766
767
815
768 def setup(self,path,set=None,format=None):
816 def __setHeaderByObj(self):
817 self.m_BasicHeader = self.m_Voltage.m_BasicHeader.copy()
818 self.m_SystemHeader = self.m_Voltage.m_SystemHeader.copy()
819 self.m_RadarControllerHeader = self.m_Voltage.m_RadarControllerHeader.copy()
820 self.m_ProcessingHeader = self.m_Voltage.m_ProcessingHeader.copy()
821 self.__dataType = self.m_Voltage.dataType
822
823 def __setHeaderByFile(self):
824
825 format = self.__format
826 header = ['Basic','System','RadarController','Processing']
827
828 fmtFromFile = None
829 headerFromFile = None
830
831
832 fileTable = self.__configHeaderFile
769
833
770 if set == None:
834 if os.access(fileTable, os.R_OK):
771 set = -1
835 import re, string
836
837 f = open(fileTable,'r')
838 lines = f.read()
839 f.close()
840
841 #Delete comments into expConfig
842 while 1:
843
844 startComment = string.find(lines.lower(),'#')
845 if startComment == -1:
846 break
847 endComment = string.find(lines.lower(),'\n',startComment)
848 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
849
850 while expFromFile == None:
851
852 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
853 nextFmt = string.find(lines.lower(),'format',currFmt+10)
854
855 if currFmt == -1:
856 break
857 if nextFmt == -1:
858 nextFmt = len(lines)-1
859
860 fmtTable = lines[currFmt:nextFmt]
861 lines = lines[nextFmt:]
862
863 fmtRead = self.__getValueFromArg(fmtTable,'format')
864 if fmtRead != format:
865 continue
866 fmtFromFile = fmtRead
867
868 lines2 = fmtTable
869
870 while headerFromFile == None:
871
872 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
873 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
874
875 if currHeader == -1:
876 break
877 if nextHeader == -1:
878 nextHeader = len(lines2)-1
879
880 headerTable = lines2[currHeader:nextHeader]
881 lines2 = lines2[nextHeader:]
882
883 headerRead = self.__getValueFromArg(headerTable,'site')
884 if not(headerRead in header):
885 continue
886 headerFromFile = headerRead
887
888 if headerRead == 'Basic':
889 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
890 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
891 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
892 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
893 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
894 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
895 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
896 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
897
772 else:
898 else:
773 set -= 1
899 print "file access denied:%s"%fileTable
900 sys.exit(0)
901
902 def setup(self,path,set=0,format='rawdata'):
903
774
904
775 if format == 'hdf5':
905 if format == 'hdf5':
776 ext = '.hdf5'
906 ext = '.hdf5'
907 format = 'hdf5'
777 print 'call hdf5 library'
908 print 'call hdf5 library'
778 return 0
909 return 0
779
910
780 if format == 'rawdata':
911 if format == 'rawdata':
781 ext = '.r'
912 ext = '.r'
913 format = 'Jicamarca'
782
914
783 #call to config_headers
915 #call to config_headers
784
916 #self.__setHeaderByFile()
785 self.__setFile = set
917 self.__setHeaderByObj()
918 self.__path = path
919 self.__setFile = set - 1
920 self.__ext = ext
921 self.__format = format
922 self.__buffer = numpy.array([],self.__dataType)
786
923
787 if not(self.__setNextFile()):
924 if not(self.__setNextFile()):
788 print "zzzzzzzzzzzz"
789 return 0
925 return 0
790
926
791 self.__writeFirstHeader() # dentro de esta funcion se debe setear e __dataType
792
927
793 self.__buffer = numpy.array([],self.__dataType)
794
928
795
929 No newline at end of file
796
797 def __writeBasicHeader(self):
798 pass
799
800 def __writeFirstHeader(self):
801 pass No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,61 +1,65
1 '''
1 '''
2 Created on Feb 7, 2012
2 Created on Feb 7, 2012
3
3
4 @author $Author$
4 @author $Author$
5 @version $Id$
5 @version $Id$
6 '''
6 '''
7 import os, sys
7 import os, sys
8
8
9 path = os.path.split(os.getcwd())[0]
9 path = os.path.split(os.getcwd())[0]
10 sys.path.append(path)
10 sys.path.append(path)
11
11
12 from Model.Data import Data
12 from Model.Data import Data
13 from IO.HeaderIO import *
13 from IO.HeaderIO import *
14
14
15 class Voltage(Data):
15 class Voltage(Data):
16 '''
16 '''
17 classdocs
17 classdocs
18 '''
18 '''
19
19
20 def __init__(self):
20 def __init__(self):
21 '''
21 '''
22 Constructor
22 Constructor
23 '''
23 '''
24
24
25 self.m_RadarControllerHeader= RadarControllerHeader()
25 self.m_RadarControllerHeader= RadarControllerHeader()
26
26
27 self.m_ProcessingHeader= ProcessingHeader()
27 self.m_ProcessingHeader= ProcessingHeader()
28
28
29 self.m_SystemHeader= SystemHeader()
29 self.m_SystemHeader= SystemHeader()
30
30
31 self.m_BasicHeader= BasicHeader()
31 self.m_BasicHeader= BasicHeader()
32
32
33 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
33 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
34 self.data = None
34 self.data = None
35
35
36 self.heights = None
36 self.heights = None
37
37
38 self.noData = True
38 self.flagNoData = True
39
39
40 self.nProfiles = None
40 self.nProfiles = None
41
41
42 self.idProfile = None
42 self.idProfile = None
43
43
44 self.dataType = None
44 self.dataType = None
45
45
46 self.flagResetProcessing = False
47
46 def copy(self):
48 def copy(self):
47 obj = Voltage()
49 obj = Voltage()
48 obj.m_BasicHeader = self.m_BasicHeader.copy()
50 obj.m_BasicHeader = self.m_BasicHeader.copy()
49 obj.m_SystemHeader = self.m_SystemHeader.copy()
51 obj.m_SystemHeader = self.m_SystemHeader.copy()
50 obj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
52 obj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
51 obj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
53 obj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
52
54
53 obj.data = self.data
55 obj.data = self.data
54 obj.heights = self.heights
56 obj.heights = self.heights
55 obj.noData = self.noData
57 obj.flagNoData = self.flagNoData
56
58
57 obj.nProfiles = self.nProfiles
59 obj.nProfiles = self.nProfiles
58 obj.idProfile = self.idProfile
60 obj.idProfile = self.idProfile
61 obj.dataType = self.dataType
62 obj.flagResetProcessing = self.flagResetProcessing
59
63
60 return obj
64 return obj
61 No newline at end of file
65
Show file before | Show file after | Hide comments
@@ -1,59 +1,59
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author $Author$
4 @author $Author$
5 @version $Id$
5 @version $Id$
6 '''
6 '''
7 import os, sys
7 import os, sys
8 import time, datetime
8 import time, datetime
9
9
10 from Model.Voltage import Voltage
10 from Model.Voltage import Voltage
11 from IO.VoltageIO import VoltageReader
11 from IO.VoltageIO import VoltageReader
12 from Graphics.VoltagePlot import Osciloscope
12 from Graphics.VoltagePlot import Osciloscope
13
13
14 class TestSChain():
14 class TestSChain():
15
15
16
16
17 def __init__(self):
17 def __init__(self):
18 self.setValues()
18 self.setValues()
19 self.createObjects()
19 self.createObjects()
20 self.testSChain()
20 self.testSChain()
21 pass
21 pass
22
22
23 def setValues(self):
23 def setValues(self):
24
24
25 self.path = '/home/roj-idl71/Data/RAWDATA/DP_Faraday/'
25 self.path = '/home/roj-idl71/Data/RAWDATA/DP_Faraday/'
26 self.path = '/home/roj-idl71/Data/RAWDATA/IMAGING'
26 self.path = '/Users/danielangelsuarezmunoz/Documents/Projects/testWR'
27 #self.path = '/remote/puma/2004_11/DVD/'
27 #self.path = '/remote/puma/2004_11/DVD/'
28 self.startDateTime = datetime.datetime(2004,5,1,17,49,0)
28 self.startDateTime = datetime.datetime(2004,5,1,17,49,0)
29 self.endDateTime = datetime.datetime(2012,5,1,18,10,0)
29 self.endDateTime = datetime.datetime(2012,5,1,18,10,0)
30
30
31 def createObjects(self):
31 def createObjects(self):
32
32
33 self.voltageObj = Voltage()
33 self.voltageObj = Voltage()
34 self.readerObj = VoltageReader(self.voltageObj)
34 self.readerObj = VoltageReader(self.voltageObj)
35 self.plotObj = Osciloscope(self.voltageObj)
35 self.plotObj = Osciloscope(self.voltageObj)
36
36
37 self.readerObj.setup(self.path, self.startDateTime, self.endDateTime)
37 self.readerObj.setup(self.path, self.startDateTime, self.endDateTime)
38
38
39 def testSChain(self):
39 def testSChain(self):
40
40
41 while(True):
41 while(True):
42
42
43 self.readerObj.getData()
43 self.readerObj.getData()
44 self.plotObj.plotData(idProfile = 1, type='iq', ymin = -100, ymax = 100)
44 self.plotObj.plotData(idProfile = 1, type='iq', ymin = -100, ymax = 100)
45
45
46 if self.readerObj.flagResetProcessing:
46 if self.readerObj.flagResetProcessing:
47 print 'jump'
47 print 'jump'
48
48
49 # if self.readerObj.flagIsNewBlock:
49 # if self.readerObj.flagIsNewBlock:
50 # print 'Block No %04d, Time: %s'%(self.readerObj.nReadBlocks,
50 # print 'Block No %04d, Time: %s'%(self.readerObj.nReadBlocks,
51 # datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc))
51 # datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc))
52
52
53 if self.readerObj.noMoreFiles:
53 if self.readerObj.noMoreFiles:
54 break
54 break
55
55
56 self.plotObj.end()
56 self.plotObj.end()
57
57
58 if __name__ == '__main__':
58 if __name__ == '__main__':
59 TestSChain() No newline at end of file
59 TestSChain()
General Comments 0
You need to be logged in to leave comments. Login now