##// END OF EJS Templates
schain
RSS
Se agrego manejo de excepciones para la lectura del header de los archivos en formato Jicamarca....
Miguel Valdez -
r52:1dd31bd293df
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,71 +1,71
1 1 '''
2 2 Created on Feb 7, 2012
3 3
4 4 @author $Author$
5 5 @version $Id$
6 6 '''
7 7 import copy
8 8 from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
9 9
10 10 class Data:
11 11 '''
12 12 classdocs
13 13 '''
14 __type = None
14 type = None
15 15
16 16 def __init__(self):
17 17 '''
18 18 Constructor
19 19 '''
20 20 raise ValueError, "This class has not been implemented"
21 21
22 22 def copy(self, objIn=None):
23 23
24 24 if objIn == None:
25 25 return copy.deepcopy(self)
26 26
27 27 for key in objIn.__dict__.keys():
28 28 self.__dict__[key] = objIn.__dict__[key]
29 29
30 30 def deepcopy(self):
31 31
32 32 return copy.deepcopy(self)
33 33
34 34 class Noise(Data):
35 35 '''
36 36 classdocs
37 37 '''
38 38
39 39 def __init__(self):
40 40 '''
41 41 Constructor
42 42 '''
43 43 pass
44 44
45 45 class JROData(Data):
46 46 '''
47 47 classdocs
48 48 '''
49 49 m_RadarControllerHeader = RadarControllerHeader()
50 50 m_ProcessingHeader = ProcessingHeader()
51 51 m_SystemHeader = SystemHeader()
52 52 m_BasicHeader = BasicHeader()
53 m_Noise = Noise()
53 m_NoiseObj = Noise()
54 54
55 55 data = None
56 56 dataType = None
57 57
58 58 nProfiles = None
59 59 nHeights = None
60 60 nChannels = None
61 61
62 62 heights = None
63 63
64 64 flagNoData = False
65 65 flagResetProcessing = False
66 66
67 67 def __init__(self):
68 68 '''
69 69 Constructor
70 70 '''
71 71 raise ValueError, "This class has not been implemented" No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,396 +1,405
1 1 '''
2 2 Created on 23/01/2012
3 3
4 4 @author $Author: vsarmiento $
5 5 @version $Id: HeaderIO.py 37 2012-03-26 22:55:13Z vsarmiento $
6 6 '''
7 7
8 8 import numpy
9 9 import copy
10 10
11 11 class Header:
12 12
13 13 def __init__(self):
14 14 raise
15 15
16 16 def copy(self):
17 17 return copy.deepcopy(self)
18 18
19 19 def read():
20 20 pass
21 21
22 22 def write():
23 23 pass
24 24
25 25 class BasicHeader(Header):
26 26
27 27 size = None
28 28 version = None
29 29 dataBlock = None
30 30 utc = None
31 31 miliSecond = None
32 32 timeZone = None
33 33 dstFlag = None
34 34 errorCount = None
35 35 struct = None
36 36
37 37 def __init__(self):
38 38 self.size = 0
39 39 self.version = 0
40 40 self.dataBlock = 0
41 41 self.utc = 0
42 42 self.miliSecond = 0
43 43 self.timeZone = 0
44 44 self.dstFlag = 0
45 45 self.errorCount = 0
46 46 self.struct = numpy.dtype([
47 47 ('nSize','<u4'),
48 48 ('nVersion','<u2'),
49 49 ('nDataBlockId','<u4'),
50 50 ('nUtime','<u4'),
51 51 ('nMilsec','<u2'),
52 52 ('nTimezone','<i2'),
53 53 ('nDstflag','<i2'),
54 54 ('nErrorCount','<u4')
55 55 ])
56 56 pass
57 57
58 58 def read(self, fp):
59
59 try:
60 60 header = numpy.fromfile(fp, self.struct,1)
61 61 self.size = header['nSize'][0]
62 62 self.version = header['nVersion'][0]
63 63 self.dataBlock = header['nDataBlockId'][0]
64 64 self.utc = header['nUtime'][0]
65 65 self.miliSecond = header['nMilsec'][0]
66 66 self.timeZone = header['nTimezone'][0]
67 67 self.dstFlag = header['nDstflag'][0]
68 68 self.errorCount = header['nErrorCount'][0]
69 except:
70 return 0
69 71
70 72 return 1
71 73
72 74 def write(self, fp):
73 75 headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
74 76 header = numpy.array(headerTuple,self.struct)
75 77 header.tofile(fp)
76 78
77 79 return 1
78 80
79 81 class SystemHeader(Header):
80 82
81 83 size = None
82 84 numSamples = None
83 85 numProfiles = None
84 86 numChannels = None
85 87 adcResolution = None
86 88 pciDioBusWidth = None
87 89 struct = None
88 90
89 91 def __init__(self):
90 92 self.size = 0
91 93 self.numSamples = 0
92 94 self.numProfiles = 0
93 95 self.numChannels = 0
94 96 self.adcResolution = 0
95 97 self.pciDioBusWidth = 0
96 98 self.struct = numpy.dtype([
97 99 ('nSize','<u4'),
98 100 ('nNumSamples','<u4'),
99 101 ('nNumProfiles','<u4'),
100 102 ('nNumChannels','<u4'),
101 103 ('nADCResolution','<u4'),
102 104 ('nPCDIOBusWidth','<u4'),
103 105 ])
104 106
105 107
106 108 def read(self, fp):
109 try:
107 110 header = numpy.fromfile(fp,self.struct,1)
108 111 self.size = header['nSize'][0]
109 112 self.numSamples = header['nNumSamples'][0]
110 113 self.numProfiles = header['nNumProfiles'][0]
111 114 self.numChannels = header['nNumChannels'][0]
112 115 self.adcResolution = header['nADCResolution'][0]
113 116 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
114
117 except:
118 return 0
115 119
116 120 return 1
117 121
118 122 def write(self, fp):
119 123 headerTuple = (self.size,self.numSamples,self.numProfiles,self.numChannels,self.adcResolution,self.pciDioBusWidth)
120 124 header = numpy.array(headerTuple,self.struct)
121 125 header.tofile(fp)
122 126
123 127 return 1
124 128
125 129 class RadarControllerHeader(Header):
126 130
127 131 size = None
128 132 expType = None
129 133 nTx = None
130 134 ipp = None
131 135 txA = None
132 136 txB = None
133 137 numWindows = None
134 138 numTaus = None
135 139 codeType = None
136 140 line6Function = None
137 141 line5Function = None
138 142 fClock = None
139 143 prePulseBefore = None
140 144 prePulserAfter = None
141 145 rangeIpp = None
142 146 rangeTxA = None
143 147 rangeTxB = None
144 148 struct = None
145 149
146 150 def __init__(self):
147 151 self.size = 0
148 152 self.expType = 0
149 153 self.nTx = 0
150 154 self.ipp = 0
151 155 self.txA = 0
152 156 self.txB = 0
153 157 self.numWindows = 0
154 158 self.numTaus = 0
155 159 self.codeType = 0
156 160 self.line6Function = 0
157 161 self.line5Function = 0
158 162 self.fClock = 0
159 163 self.prePulseBefore = 0
160 164 self.prePulserAfter = 0
161 165 self.rangeIpp = 0
162 166 self.rangeTxA = 0
163 167 self.rangeTxB = 0
164 168 self.struct = numpy.dtype([
165 169 ('nSize','<u4'),
166 170 ('nExpType','<u4'),
167 171 ('nNTx','<u4'),
168 172 ('fIpp','<f4'),
169 173 ('fTxA','<f4'),
170 174 ('fTxB','<f4'),
171 175 ('nNumWindows','<u4'),
172 176 ('nNumTaus','<u4'),
173 177 ('nCodeType','<u4'),
174 178 ('nLine6Function','<u4'),
175 179 ('nLine5Function','<u4'),
176 180 ('fClock','<f4'),
177 181 ('nPrePulseBefore','<u4'),
178 182 ('nPrePulseAfter','<u4'),
179 183 ('sRangeIPP','<a20'),
180 184 ('sRangeTxA','<a20'),
181 185 ('sRangeTxB','<a20'),
182 186 ])
183 187 self.dynamic = numpy.array([],numpy.dtype('byte'))
184 188
185 189
186 190 def read(self, fp):
191 try:
187 192 header = numpy.fromfile(fp,self.struct,1)
188 193 self.size = header['nSize'][0]
189 194 self.expType = header['nExpType'][0]
190 195 self.nTx = header['nNTx'][0]
191 196 self.ipp = header['fIpp'][0]
192 197 self.txA = header['fTxA'][0]
193 198 self.txB = header['fTxB'][0]
194 199 self.numWindows = header['nNumWindows'][0]
195 200 self.numTaus = header['nNumTaus'][0]
196 201 self.codeType = header['nCodeType'][0]
197 202 self.line6Function = header['nLine6Function'][0]
198 203 self.line5Function = header['nLine5Function'][0]
199 204 self.fClock = header['fClock'][0]
200 205 self.prePulseBefore = header['nPrePulseBefore'][0]
201 206 self.prePulserAfter = header['nPrePulseAfter'][0]
202 207 self.rangeIpp = header['sRangeIPP'][0]
203 208 self.rangeTxA = header['sRangeTxA'][0]
204 209 self.rangeTxB = header['sRangeTxB'][0]
205 210 # jump Dynamic Radar Controller Header
206 211 jumpHeader = self.size - 116
207 212 self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpHeader)
213 except:
214 return 0
208 215
209 216 return 1
210 217
211 218 def write(self, fp):
212 219 headerTuple = (self.size,
213 220 self.expType,
214 221 self.nTx,
215 222 self.ipp,
216 223 self.txA,
217 224 self.txB,
218 225 self.numWindows,
219 226 self.numTaus,
220 227 self.codeType,
221 228 self.line6Function,
222 229 self.line5Function,
223 230 self.fClock,
224 231 self.prePulseBefore,
225 232 self.prePulserAfter,
226 233 self.rangeIpp,
227 234 self.rangeTxA,
228 235 self.rangeTxB)
229 236
230 237 header = numpy.array(headerTuple,self.struct)
231 238 header.tofile(fp)
232 239
233 240 dynamic = self.dynamic
234 241 dynamic.tofile(fp)
235 242
236 243 return 1
237 244
238 245
239 246
240 247 class ProcessingHeader(Header):
241 248
242 249 size = None
243 250 dataType = None
244 251 blockSize = None
245 252 profilesPerBlock = None
246 253 dataBlocksPerFile = None
247 254 numWindows = None
248 255 processFlags = None
249 256 coherentInt = None
250 257 incoherentInt = None
251 258 totalSpectra = None
252 259 struct = None
253 260
254 261 def __init__(self):
255 262 self.size = 0
256 263 self.dataType = 0
257 264 self.blockSize = 0
258 265 self.profilesPerBlock = 0
259 266 self.dataBlocksPerFile = 0
260 267 self.numWindows = 0
261 268 self.processFlags = 0
262 269 self.coherentInt = 0
263 270 self.incoherentInt = 0
264 271 self.totalSpectra = 0
265 272 self.struct = numpy.dtype([
266 273 ('nSize','<u4'),
267 274 ('nDataType','<u4'),
268 275 ('nSizeOfDataBlock','<u4'),
269 276 ('nProfilesperBlock','<u4'),
270 277 ('nDataBlocksperFile','<u4'),
271 278 ('nNumWindows','<u4'),
272 279 ('nProcessFlags','<u4'),
273 280 ('nCoherentIntegrations','<u4'),
274 281 ('nIncoherentIntegrations','<u4'),
275 282 ('nTotalSpectra','<u4')
276 283 ])
277 284 self.samplingWindow = 0
278 285 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
279 286 self.numHeights = 0
280 287 self.firstHeight = 0
281 288 self.deltaHeight = 0
282 289 self.samplesWin = 0
283 290 self.spectraComb = 0
284 291 self.numCode = 0
285 292 self.codes = 0
286 293 self.numBaud = 0
287 294 self.shif_fft = False
288 295
289 296 def read(self, fp):
297 try:
290 298 header = numpy.fromfile(fp,self.struct,1)
291 299 self.size = header['nSize'][0]
292 300 self.dataType = header['nDataType'][0]
293 301 self.blockSize = header['nSizeOfDataBlock'][0]
294 302 self.profilesPerBlock = header['nProfilesperBlock'][0]
295 303 self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
296 304 self.numWindows = header['nNumWindows'][0]
297 305 self.processFlags = header['nProcessFlags']
298 306 self.coherentInt = header['nCoherentIntegrations'][0]
299 307 self.incoherentInt = header['nIncoherentIntegrations'][0]
300 308 self.totalSpectra = header['nTotalSpectra'][0]
301 309 self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.numWindows)
302 310 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
303 311 self.firstHeight = self.samplingWindow['h0']
304 312 self.deltaHeight = self.samplingWindow['dh']
305 313 self.samplesWin = self.samplingWindow['nsa']
306 314 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
307 315
308 316 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
309 317 self.numCode = numpy.fromfile(fp,'<u4',1)
310 318 self.numBaud = numpy.fromfile(fp,'<u4',1)
311 319 self.codes = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode)
312 320
313 321 if self.processFlags & PROCFLAG.SHIFT_FFT_DATA == PROCFLAG.SHIFT_FFT_DATA:
314 322 self.shif_fft = True
315 323 else:
316 324 self.shif_fft = False
317
325 except:
326 return 0
318 327
319 328 return 1
320 329
321 330 def write(self, fp):
322 331 headerTuple = (self.size,
323 332 self.dataType,
324 333 self.blockSize,
325 334 self.profilesPerBlock,
326 335 self.dataBlocksPerFile,
327 336 self.numWindows,
328 337 self.processFlags,
329 338 self.coherentInt,
330 339 self.incoherentInt,
331 340 self.totalSpectra)
332 341
333 342 header = numpy.array(headerTuple,self.struct)
334 343 header.tofile(fp)
335 344
336 345 if self.numWindows != 0:
337 346 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
338 347 samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
339 348 samplingWindow.tofile(fp)
340 349
341 350
342 351 if self.totalSpectra != 0:
343 352 spectraComb = numpy.array([],numpy.dtype('u1'))
344 353 spectraComb = self.spectraComb
345 354 spectraComb.tofile(fp)
346 355
347 356
348 357 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
349 358 numCode = self.numCode
350 359 numCode.tofile(fp)
351 360
352 361 numBaud = self.numBaud
353 362 numBaud.tofile(fp)
354 363
355 364 codes = self.codes.reshape(numCode*numBaud)
356 365 codes.tofile(fp)
357 366
358 367 return 1
359 368
360 369
361 370 class PROCFLAG:
362 371 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
363 372 DECODE_DATA = numpy.uint32(0x00000002)
364 373 SPECTRA_CALC = numpy.uint32(0x00000004)
365 374 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
366 375 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
367 376 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
368 377
369 378 DATATYPE_CHAR = numpy.uint32(0x00000040)
370 379 DATATYPE_SHORT = numpy.uint32(0x00000080)
371 380 DATATYPE_LONG = numpy.uint32(0x00000100)
372 381 DATATYPE_INT64 = numpy.uint32(0x00000200)
373 382 DATATYPE_FLOAT = numpy.uint32(0x00000400)
374 383 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
375 384
376 385 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
377 386 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
378 387 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
379 388
380 389 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
381 390 DEFLIP_DATA = numpy.uint32(0x00010000)
382 391 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
383 392
384 393 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
385 394 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
386 395 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
387 396 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
388 397 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
389 398
390 399 EXP_NAME_ESP = numpy.uint32(0x00200000)
391 400 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
392 401
393 402 OPERATION_MASK = numpy.uint32(0x0000003F)
394 403 DATATYPE_MASK = numpy.uint32(0x00000FC0)
395 404 DATAARRANGE_MASK = numpy.uint32(0x00007000)
396 405 ACQ_SYS_MASK = numpy.uint32(0x001C0000) No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,54 +1,57
1 1 '''
2 2 Created on Feb 7, 2012
3 3
4 4 @author $Author$
5 5 @version $Id$
6 6 '''
7 7
8 8 from JROData import JROData, Noise
9 9 from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
10 10
11 11 class Spectra(JROData):
12 12 '''
13 13 classdocs
14 14 '''
15 15
16 type = "Spectra"
16 17 data_spc = None
17 18 data_cspc = None
18 19 data_dc = None
19 20 nPairs = 0
20 21
21 22
22 23 def __init__(self):
23 24 '''
24 25 Constructor
25 26 '''
26 27
27 28 self.m_RadarControllerHeader = RadarControllerHeader()
28 29
29 30 self.m_ProcessingHeader = ProcessingHeader()
30 31
31 32 self.m_SystemHeader = SystemHeader()
32 33
33 34 self.m_BasicHeader = BasicHeader()
34 35
35 self.noise = Noise()
36 m_NoiseObj = Noise()
36 37
37 38 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
38 39 self.data_spc = None
40
39 41 self.data_cspc = None
42
40 43 self.data_dc = None
41 44
42 45 self.heights = None
43 46
44 47 self.flagNoData = True
45 48
46 49 self.nProfiles = None
47 50
48 51 self.dataType = None
49 52
50 53 self.flagResetProcessing = False
51 54
52 55 self.nPairs = 0
53 56
54 57 self.nChannels = 0 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,48 +1,49
1 1 '''
2 2 Created on Feb 7, 2012
3 3
4 4 @author $Author$
5 5 @version $Id$
6 6 '''
7 7
8 8 from JROData import JROData, Noise
9 9 from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
10 10
11 11 class Voltage(JROData):
12 12 '''
13 13 classdocs
14 14 '''
15 15
16 type = "Voltage"
16 17 data = None
17 18 profileIndex = None
18 19
19 20 def __init__(self):
20 21 '''
21 22 Constructor
22 23 '''
23 24
24 25 self.m_RadarControllerHeader= RadarControllerHeader()
25 26
26 27 self.m_ProcessingHeader= ProcessingHeader()
27 28
28 29 self.m_SystemHeader= SystemHeader()
29 30
30 31 self.m_BasicHeader= BasicHeader()
31 32
32 self.noise = Noise()
33 m_NoiseObj = Noise()
33 34
34 35 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
35 36 self.data = None
36 37
37 38 self.dataType = None
38 39
39 40 self.heights = None
40 41
41 42 self.profileIndex = None
42 43
43 44 self.nProfiles = None
44 45
45 46 self.flagNoData = True
46 47
47 48 self.flagResetProcessing = False
48 49 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now