##// END OF EJS Templates
schain
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,10 +55,25 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
71
72 pts2read_SelfSpectra = 0
73 pts2read_CrossSpectra = 0
74 pts2read_DCchannels = 0
75
76 ext = ".pdata"
58 77
59 78
60 79 def __init__(self,m_Spectra=None):
@@ -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 """
@@ -86,92 +101,28 class SpectraReader( JRODataReader ):
86 101
87 102 self.m_DataObj = m_Spectra
88 103
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
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
158
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
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
174 122
123 Return:
124 None
125 """
175 126 self.nChannels = 0
176 127 self.nPairs = 0
177 128
@@ -191,6 +142,7 class SpectraReader( JRODataReader ):
191 142 self.m_DataObj.nChannels = self.nChannels
192 143 self.m_DataObj.nPairs = self.nPairs
193 144
145
194 146 def readBlock(self):
195 147 """
196 148 Lee el bloque de datos desde la posicion actual del puntero del archivo
@@ -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,17 +271,30 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
279
336 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
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
342 298 def __init__(self,m_Spectra=None):
343 299 """
344 300 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
@@ -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
359 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()
314 if not( isinstance(m_Spectra, Spectra) ):
315 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
396 316
397 self.m_ProcessingHeader = ProcessingHeader()
317 self.m_DataObj = m_Spectra
398 318
399 self.data_spc = None
400 self.data_cspc = None
401 self.data_dc = None
402 319
403 320 def hasAllDataInBuffer(self):
404 321 return 1
405 322
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,10 +57,21 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 77 def __init__(self,m_Voltage=None):
@@ -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()
@@ -92,98 +100,28 class VoltageReader(JRODataReader):
92 100
93 101 self.m_DataObj = m_Voltage
94 102
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
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 103
173 self.utc = 0
174
175 self.nBlocks = 0
176
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
186 123
124
187 125 def readBlock(self):
188 126 """
189 127 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
@@ -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()
@@ -247,6 +185,7 class VoltageReader(JRODataReader):
247 185
248 186 return 1
249 187
188
250 189 def getData(self):
251 190 """
252 191 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
@@ -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,77 +263,61 class VoltageWriter( JRODataWriter ):
323 263 """
324 264 __configHeaderFile = 'wrSetHeadet.txt'
325 265
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
326 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
342 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()
291 if not( isinstance(m_Voltage, Voltage) ):
292 raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
379 293
380 self.m_RadarControllerHeader = RadarControllerHeader()
294 self.m_DataObj = m_Voltage
381 295
382 self.m_ProcessingHeader = ProcessingHeader()
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):
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
390 311
312 Return: None
313 """
391 314 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
392 315 self.m_ProcessingHeader.numHeights,
393 316 self.m_SystemHeader.numChannels )
394 317
395 318 self.datablock = numpy.zeros(self.shapeBuffer, numpy.dtype('complex'))
396 319
320
397 321 def writeBlock(self):
398 322 """
399 323 Escribe el buffer en el file designado
@@ -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 388
No newline at end of file
463
464 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now