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