##// END OF EJS Templates
schain-jc
RSS
IO:...
Victor Sarmiento -
r59:4a1c54fb9a59
parent child
Show More
Show file before | Show file after | Hide comments
@@ -29,6 +29,10 class SpectraReader( JRODataReader ):
29 29 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
30 30 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
31 31
32 pares * alturas * perfiles (Self Spectra)
33 canales * alturas * perfiles (Cross Spectra)
34 canales * alturas (DC Channels)
35
32 36 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
33 37 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
34 38 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
@@ -51,13 +55,28 class SpectraReader( JRODataReader ):
51 55
52 56 print readerObj.m_Spectra.data
53 57
54 if readerObj.noMoreFiles:
58 if readerObj.flagNoMoreFiles:
55 59 break
56 60
57 61 """
62 m_DataObj = None
63
64 data_spc = None
65 data_cspc = None
66 data_dc = None
67
68 nChannels = 0
69
70 nPairs = 0
58 71
72 pts2read_SelfSpectra = 0
73 pts2read_CrossSpectra = 0
74 pts2read_DCchannels = 0
59 75
60 def __init__(self,m_Spectra=None):
76 ext = ".pdata"
77
78
79 def __init__(self, m_Spectra=None):
61 80 """
62 81 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
63 82
@@ -71,10 +90,6 class SpectraReader( JRODataReader ):
71 90
72 91 Affected:
73 92 self.m_DataObj
74 self.m_BasicHeader
75 self.m_SystemHeader
76 self.m_RadarControllerHeader
77 self.m_ProcessingHeader
78 93
79 94 Return : None
80 95 """
@@ -83,95 +98,31 class SpectraReader( JRODataReader ):
83 98
84 99 if not( isinstance(m_Spectra, Spectra) ):
85 100 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
86
87 self.m_DataObj = m_Spectra
88
89 self.m_BasicHeader = BasicHeader()
90
91 self.m_SystemHeader = SystemHeader()
92
93 self.m_RadarControllerHeader = RadarControllerHeader()
94
95 self.m_ProcessingHeader = ProcessingHeader()
96
97 self.fp = None
98
99 self.idFile = None
100
101 self.startDateTime = None
102
103 self.endDateTime = None
104
105 self.dataType = None
106
107 self.fileSizeByHeader = 0
108
109 self.pathList = []
110
111 self.filenameList = []
112
113 self.lastUTTime = 0
114
115 self.maxTimeStep = 30
116
117 self.flagIsNewFile = 0
118
119 self.flagResetProcessing = 0
120
121 self.flagIsNewBlock = 0
122
123 self.noMoreFiles = 0
124
125 self.nReadBlocks = 0
126
127 self.online = 0
128
129 self.firstHeaderSize = 0
130
131 self.basicHeaderSize = 24
132
133 self.filename = None
134
135 self.fileSize = None
136
137 self.data_spc = None
138 self.data_cspc = None
139 self.data_dc = None
140 101
141 self.nChannels = 0
142 self.nPairs = 0
143
144 self.pts2read_SelfSpectra = 0
145 self.pts2read_CrossSpectra = 0
146 self.pts2read_DCchannels = 0
147 self.blocksize = 0
148
149 self.datablockIndex = 0
150
151 self.ippSeconds = 0
152
153 self.nSelfChannels = 0
154
155 self.nCrossPairs = 0
156
157 self.datablock_id = 9999
102 self.m_DataObj = m_Spectra
158 103
159 self.delay = 2 #seconds
160 self.nTries = 3 #quantity tries
161 self.nFiles = 3 #number of files for searching
162 self.year = 0
163 self.doy = 0
164 self.set = 0
165 self.ext = ".pdata"
166 self.path = None
167 self.optchar = "P"
168 self.nBlocks = 0
169 104
170 def hasNotDataInBuffer(self):
105 def __hasNotDataInBuffer(self):
171 106 return 1
172 107
108
173 109 def getBlockDimension(self):
110 """
111 Obtiene la cantidad de puntos a leer por cada bloque de datos
174 112
113 Affected:
114 self.nChannels
115 self.nPairs
116 self.pts2read_SelfSpectra
117 self.pts2read_CrossSpectra
118 self.pts2read_DCchannels
119 self.blocksize
120 self.m_DataObj.nChannels
121 self.m_DataObj.nPairs
122
123 Return:
124 None
125 """
175 126 self.nChannels = 0
176 127 self.nPairs = 0
177 128
@@ -190,6 +141,7 class SpectraReader( JRODataReader ):
190 141
191 142 self.m_DataObj.nChannels = self.nChannels
192 143 self.m_DataObj.nPairs = self.nPairs
144
193 145
194 146 def readBlock(self):
195 147 """
@@ -212,10 +164,6 class SpectraReader( JRODataReader ):
212 164 Exceptions:
213 165 Si un bloque leido no es un bloque valido
214 166 """
215 #self.datablock_id = 0
216 #self.flagIsNewFile = 0
217 #self.flagIsNewBlock = 1
218
219 167 blockOk_flag = False
220 168 fpointer = self.fp.tell()
221 169
@@ -226,10 +174,7 class SpectraReader( JRODataReader ):
226 174 if self.online:
227 175 if (spc.size + cspc.size + dc.size) != self.blocksize:
228 176 for nTries in range( self.nTries ):
229 #nTries = 0
230 #while( nTries < self.nTries ):
231 #nTries += 1
232 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
177 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
233 178 time.sleep( self.delay )
234 179 self.fp.seek( fpointer )
235 180 fpointer = self.fp.tell()
@@ -240,13 +185,8 class SpectraReader( JRODataReader ):
240 185 if (spc.size + cspc.size + dc.size) == self.blocksize:
241 186 blockOk_flag = True
242 187 break
243 #if (spc.size + cspc.size + dc.size) == self.blocksize:
244 # nTries = 0
245 # break
246 188 if not( blockOk_flag ):
247 189 return 0
248 #if nTries > 0:
249 # return 0
250 190
251 191 try:
252 192 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
@@ -268,7 +208,7 class SpectraReader( JRODataReader ):
268 208 self.data_cspc = cspc['real'] + cspc['imag']*1j
269 209 self.data_dc = dc['real'] + dc['imag']*1j
270 210
271 self.datablock_id = 0
211 self.datablockIndex = 0
272 212 self.flagIsNewFile = 0
273 213 self.flagIsNewBlock = 1
274 214
@@ -277,6 +217,7 class SpectraReader( JRODataReader ):
277 217
278 218 return 1
279 219
220
280 221 def getData(self):
281 222 """
282 223 Copia el buffer de lectura a la clase "Spectra",
@@ -294,10 +235,12 class SpectraReader( JRODataReader ):
294 235 self.flagIsNewBlock
295 236 """
296 237
238 if self.flagNoMoreFiles: return 0
239
297 240 self.flagResetProcessing = 0
298 241 self.flagIsNewBlock = 0
299 242
300 if self.hasNotDataInBuffer():
243 if self.__hasNotDataInBuffer():
301 244
302 245 if not( self.readNextBlock() ):
303 246 self.setNextFile()
@@ -310,14 +253,14 class SpectraReader( JRODataReader ):
310 253 self.m_DataObj.heights = self.heights
311 254 self.m_DataObj.dataType = self.dataType
312 255
313 if self.noMoreFiles == 1:
256 if self.flagNoMoreFiles == 1:
314 257 print 'Process finished'
315 258 return 0
316 259
317 260 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
318 261
319 262 if self.data_dc == None:
320 self.m_Voltage.flagNoData = True
263 self.m_DataObj.flagNoData = True
321 264 return 0
322 265
323 266 self.m_DataObj.flagNoData = False
@@ -328,18 +271,31 class SpectraReader( JRODataReader ):
328 271 self.m_DataObj.data_dc = self.data_dc
329 272
330 273 #call setData - to Data Object
331 #self.datablock_id += 1
274 #self.datablockIndex += 1
332 275 #self.idProfile += 1
333 276
334 277 return 1
335 278
336 class SpectraWriter( JRODataWriter ):
279
280 class SpectraWriter(JRODataWriter):
281
337 282 """
338 283 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
339 284 de los datos siempre se realiza por bloques.
340 285 """
341 286
342 def __init__(self,m_Spectra=None):
287 m_DataObj = None
288
289 ext = ".pdata"
290
291 optchar = "P"
292
293 shape_spc_Buffer = None
294 shape_cspc_Buffer = None
295 shape_dc_Buffer = None
296
297
298 def __init__(self, m_Spectra=None):
343 299 """
344 300 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
345 301
@@ -352,59 +308,30 class SpectraWriter( JRODataWriter ):
352 308
353 309 Return: None
354 310 """
355
356 311 if m_Spectra == None:
357 312 m_Spectra = Spectra()
358 313
314 if not( isinstance(m_Spectra, Spectra) ):
315 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
316
359 317 self.m_DataObj = m_Spectra
360
361 self.fp = None
362
363 self.format = None
364
365 self.blocksCounter = 0
366
367 self.setFile = None
368
369 self.flagIsNewFile = 1
370
371 self.dataType = None
372
373 self.ext = ".pdata"
374
375 self.path = None
376
377 self.optchar = "P"
378
379 self.shape_spc_Buffer = None
380 self.shape_cspc_Buffer = None
381 self.shape_dc_Buffer = None
382
383 self.nWriteBlocks = 0
384
385 self.flagIsNewBlock = 0
386
387 self.noMoreFiles = 0
388
389 self.filename = None
390
391 self.m_BasicHeader= BasicHeader()
392
393 self.m_SystemHeader = SystemHeader()
394
395 self.m_RadarControllerHeader = RadarControllerHeader()
396
397 self.m_ProcessingHeader = ProcessingHeader()
398
399 self.data_spc = None
400 self.data_cspc = None
401 self.data_dc = None
402 318
319
403 320 def hasAllDataInBuffer(self):
404 321 return 1
322
405 323
406 324 def setBlockDimension(self):
325 """
326 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
327
328 Affected:
329 self.shape_spc_Buffer
330 self.shape_cspc_Buffer
331 self.shape_dc_Buffer
407 332
333 Return: None
334 """
408 335 self.shape_spc_Buffer = (self.m_DataObj.nChannels,
409 336 self.m_ProcessingHeader.numHeights,
410 337 self.m_ProcessingHeader.profilesPerBlock)
@@ -463,6 +390,7 class SpectraWriter( JRODataWriter ):
463 390 self.nWriteBlocks += 1
464 391 self.blocksCounter += 1
465 392
393
466 394 def putData(self):
467 395 """
468 396 Setea un bloque de datos y luego los escribe en un file
@@ -491,11 +419,12 class SpectraWriter( JRODataWriter ):
491 419 self.data_cspc = self.m_DataObj.data_cspc
492 420 self.data_dc = self.m_DataObj.data_dc
493 421
422 # #self.m_ProcessingHeader.dataBlocksPerFile)
494 423 if True:
495 424 self.getHeader()
496 425 self.writeNextBlock()
497 426
498 if self.noMoreFiles:
427 if self.flagNoMoreFiles:
499 428 #print 'Process finished'
500 429 return 0
501 430
Show file before | Show file after | Hide comments
@@ -20,12 +20,15 from Model.Voltage import Voltage
20 20 from IO.DataIO import JRODataReader
21 21 from IO.DataIO import JRODataWriter
22 22
23
23 24 class VoltageReader(JRODataReader):
24 25 """
25 26 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
26 27 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
27 28 perfiles*alturas*canales) son almacenados en la variable "buffer".
28 29
30 Voltajes - perfiles * alturas * canales
31
29 32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
30 33 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
31 34 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
@@ -54,13 +57,24 class VoltageReader(JRODataReader):
54 57 #If you want to see all datablock
55 58 print readerObj.datablock
56 59
57 if readerObj.noMoreFiles:
60 if readerObj.flagNoMoreFiles:
58 61 break
59 62
60 63 """
64 m_DataObj = None
65
66 idProfile = 0
67
68 datablock = None
69
70 ext = ".r"
71
72 pts2read = 0
73
74 utc = 0
61 75
62 76
63 def __init__(self,m_Voltage=None):
77 def __init__(self, m_Voltage=None):
64 78 """
65 79 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
66 80
@@ -74,15 +88,9 class VoltageReader(JRODataReader):
74 88
75 89 Variables afectadas:
76 90 self.m_DataObj
77 self.m_BasicHeader
78 self.m_SystemHeader
79 self.m_RadarControllerHeader
80 self.m_ProcessingHeader
81
82 91
83 92 Return:
84 Void
85
93 None
86 94 """
87 95 if m_Voltage == None:
88 96 m_Voltage = Voltage()
@@ -91,98 +99,28 class VoltageReader(JRODataReader):
91 99 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
92 100
93 101 self.m_DataObj = m_Voltage
94
95 self.m_BasicHeader = BasicHeader()
96
97 self.m_SystemHeader = SystemHeader()
98
99 self.m_RadarControllerHeader = RadarControllerHeader()
100
101 self.m_ProcessingHeader = ProcessingHeader()
102
103 self.fp = None
104
105 self.idFile = None
106
107 self.startDateTime = None
108
109 self.endDateTime = None
110
111 self.dataType = None
112
113 self.fileSizeByHeader = 0
114
115 self.pathList = []
116
117 self.filenameList = []
118
119 self.lastUTTime = 0
120
121 self.maxTimeStep = 30
122
123 self.flagIsNewFile = 0
124
125 self.ippSeconds = 0
126
127 self.flagResetProcessing = 0
128
129 self.flagIsNewBlock = 0
130
131 self.noMoreFiles = 0
132
133 self.nReadBlocks = 0
134
135 self.online = 0
136
137 self.filename = None
138
139 self.fileSize = None
140
141 self.firstHeaderSize = 0
142
143 self.basicHeaderSize = 24
144
145 self.idProfile = 0
146
147 self.datablock = None
148
149 self.datablockIndex = 9999
150 102
151 self.delay = 7 #seconds
152
153 self.nTries = 3 #quantity tries
154
155 self.nFiles = 3 #number of files for searching
156
157 self.year = 0
158
159 self.doy = 0
160
161 self.set = 0
162
163 self.ext = ".r"
164
165 self.path = None
166
167 self.optchar = "D"
168
169 self.pts2read = 0
170
171 self.blocksize = 0
172
173 self.utc = 0
174
175 self.nBlocks = 0
176 103
177 def hasNotDataInBuffer(self):
104 def __hasNotDataInBuffer(self):
178 105 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
179 106 return 1
180 107 return 0
181 108
109
182 110 def getBlockDimension(self):
111 """
112 Obtiene la cantidad de puntos a leer por cada bloque de datos
183 113
114 Affected:
115 self.pts2read
116 self.blocksize
117
118 Return:
119 None
120 """
184 121 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
185 122 self.blocksize = self.pts2read
123
186 124
187 125 def readBlock(self):
188 126 """
@@ -216,7 +154,7 class VoltageReader(JRODataReader):
216 154 if self.online:
217 155 if junk.size != self.blocksize:
218 156 for nTries in range( self.nTries ):
219 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
157 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
220 158 time.sleep( self.delay )
221 159 self.fp.seek( fpointer )
222 160 fpointer = self.fp.tell()
@@ -246,6 +184,7 class VoltageReader(JRODataReader):
246 184 self.nBlocks += 1
247 185
248 186 return 1
187
249 188
250 189 def getData(self):
251 190 """
@@ -271,12 +210,12 class VoltageReader(JRODataReader):
271 210 self.flagIsNewBlock
272 211 self.idProfile
273 212 """
274 if self.noMoreFiles: return 0
213 if self.flagNoMoreFiles: return 0
275 214
276 215 self.flagResetProcessing = 0
277 216 self.flagIsNewBlock = 0
278 217
279 if self.hasNotDataInBuffer():
218 if self.__hasNotDataInBuffer():
280 219
281 220 if not( self.readNextBlock() ):
282 221 self.setNextFile()
@@ -289,7 +228,7 class VoltageReader(JRODataReader):
289 228 self.m_DataObj.heights = self.heights
290 229 self.m_DataObj.dataType = self.dataType
291 230
292 if self.noMoreFiles == 1:
231 if self.flagNoMoreFiles == 1:
293 232 print 'Process finished'
294 233 return 0
295 234
@@ -316,6 +255,7 class VoltageReader(JRODataReader):
316 255
317 256 return 1 #self.m_DataObj.data
318 257
258
319 259 class VoltageWriter( JRODataWriter ):
320 260 """
321 261 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
@@ -323,76 +263,60 class VoltageWriter( JRODataWriter ):
323 263 """
324 264 __configHeaderFile = 'wrSetHeadet.txt'
325 265
326 def __init__(self,m_Voltage=None):
266 m_DataObj = None
267
268 datablock = None
269
270 datablockIndex = 0
271
272 ext = ".r"
273
274 optchar = "D"
275
276 shapeBuffer = None
277
278
279 def __init__(self, m_Voltage=None):
327 280 """
328 281 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
329 282
330 283 Affected:
331 284 self.m_DataObj
332 self.m_BasicHeader
333 self.m_SystemHeader
334 self.m_RadarControllerHeader
335 self.m_ProcessingHeader
336 285
337 286 Return: None
338 287 """
339 288 if m_Voltage == None:
340 289 m_Voltage = Voltage()
341 290
291 if not( isinstance(m_Voltage, Voltage) ):
292 raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
293
342 294 self.m_DataObj = m_Voltage
343
344 self.fp = None
345
346 self.format = None
347
348 self.blocksCounter = 0
349
350 self.setFile = None
351
352 self.flagIsNewFile = 1
353
354 self.datablock = None
355
356 self.datablockIndex = 0
357
358 self.dataType = None
359
360 self.ext = ".r"
361
362 self.path = None
363
364 self.optchar = "D"
365
366 self.shapeBuffer = None
367
368 self.nWriteBlocks = 0
369
370 self.flagIsNewBlock = 0
371
372 self.noMoreFiles = 0
373
374 self.filename = None
375
376 self.m_BasicHeader= BasicHeader()
377
378 self.m_SystemHeader = SystemHeader()
379
380 self.m_RadarControllerHeader = RadarControllerHeader()
381
382 self.m_ProcessingHeader = ProcessingHeader()
295
383 296
384 297 def hasAllDataInBuffer(self):
385 298 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
386 299 return 1
387 300 return 0
388 301
302
389 303 def setBlockDimension(self):
390
391 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
392 self.m_ProcessingHeader.numHeights,
393 self.m_SystemHeader.numChannels )
304 """
305 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
306
307 Affected:
308 self.shape_spc_Buffer
309 self.shape_cspc_Buffer
310 self.shape_dc_Buffer
311
312 Return: None
313 """
314 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
315 self.m_ProcessingHeader.numHeights,
316 self.m_SystemHeader.numChannels )
394 317
395 318 self.datablock = numpy.zeros(self.shapeBuffer, numpy.dtype('complex'))
319
396 320
397 321 def writeBlock(self):
398 322 """
@@ -423,6 +347,7 class VoltageWriter( JRODataWriter ):
423 347 self.nWriteBlocks += 1
424 348 self.blocksCounter += 1
425 349
350
426 351 def putData(self):
427 352 """
428 353 Setea un bloque de datos y luego los escribe en un file
@@ -451,14 +376,13 class VoltageWriter( JRODataWriter ):
451 376 self.datablockIndex += 1
452 377
453 378 if self.hasAllDataInBuffer():
379 #if self.flagIsNewFile:
454 380 self.getHeader()
455 381 self.writeNextBlock()
456 382
457 if self.noMoreFiles:
383 if self.flagNoMoreFiles:
458 384 #print 'Process finished'
459 385 return 0
460 386
461 387 return 1
462
463
464 388 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now