##// END OF EJS Templates
schain-jc
RSS
Victor Sarmiento -
r62:d2243c994131
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,433 +1,434
1 1 '''
2 2 File: SpectraIO.py
3 3 Created on 20/02/2012
4 4
5 5 @author $Author$
6 6 @version $Id$
7 7 '''
8 8
9 9 import os, sys
10 10 import numpy
11 11 import glob
12 12 import fnmatch
13 13 import time, datetime
14 14
15 15 path = os.path.split(os.getcwd())[0]
16 16 sys.path.append(path)
17 17
18 18 from Model.JROHeader import *
19 19 from Model.Spectra import Spectra
20 20
21 21 from DataIO import JRODataReader
22 22 from DataIO import JRODataWriter
23 23 from DataIO import isNumber
24 24
25 25
26 26 class SpectraReader( JRODataReader ):
27 27 """
28 28 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
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 32 pares * alturas * perfiles (Self Spectra)
33 33 canales * alturas * perfiles (Cross Spectra)
34 34 canales * alturas (DC Channels)
35 35
36 36 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
37 37 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
38 38 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
39 39 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
40 40
41 41 Example:
42 42 dpath = "/home/myuser/data"
43 43
44 44 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
45 45
46 46 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
47 47
48 48 readerObj = SpectraReader()
49 49
50 50 readerObj.setup(dpath, startTime, endTime)
51 51
52 52 while(True):
53 53
54 54 readerObj.getData()
55 55
56 56 print readerObj.m_Spectra.data
57 57
58 58 if readerObj.flagNoMoreFiles:
59 59 break
60 60
61 61 """
62 62 m_DataObj = None
63 63
64 64 data_spc = None
65 65 data_cspc = None
66 66 data_dc = None
67 67
68 nChannels = 0
68 nPairsEqualChannels = 0
69 69
70 nPairs = 0
70 nPairsUnequalChannels = 0
71 71
72 72 pts2read_SelfSpectra = 0
73 73 pts2read_CrossSpectra = 0
74 74 pts2read_DCchannels = 0
75 75
76 76 ext = ".pdata"
77 77
78 78
79 79 def __init__(self, m_Spectra=None):
80 80 """
81 81 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
82 82
83 83 Inputs:
84 84 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
85 85 almacenar un perfil de datos cada vez que se haga un requerimiento
86 86 (getData). El perfil sera obtenido a partir del buffer de datos,
87 87 si el buffer esta vacio se hara un nuevo proceso de lectura de un
88 88 bloque de datos.
89 89 Si este parametro no es pasado se creara uno internamente.
90 90
91 91 Affected:
92 92 self.m_DataObj
93 93
94 94 Return : None
95 95 """
96 96 if m_Spectra == None:
97 97 m_Spectra = Spectra()
98 98
99 99 if not( isinstance(m_Spectra, Spectra) ):
100 100 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
101 101
102 102 self.m_DataObj = m_Spectra
103 103
104 104
105 105 def __hasNotDataInBuffer(self):
106 106 return 1
107 107
108 108
109 109 def getBlockDimension(self):
110 110 """
111 111 Obtiene la cantidad de puntos a leer por cada bloque de datos
112 112
113 113 Affected:
114 self.nChannels
115 self.nPairs
114 self.nPairsEqualChannels
115 self.nPairsUnequalChannels
116 116 self.pts2read_SelfSpectra
117 117 self.pts2read_CrossSpectra
118 118 self.pts2read_DCchannels
119 119 self.blocksize
120 self.m_DataObj.nChannels
121 self.m_DataObj.nPairs
120 self.m_DataObj.nPairsEqualChannels
121 self.m_DataObj.nPairsUnequalChannels
122 122
123 123 Return:
124 124 None
125 125 """
126 self.nChannels = 0
127 self.nPairs = 0
126 self.nPairsEqualChannels = 0
127 self.nPairsUnequalChannels = 0
128 128
129 129 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
130 130 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
131 self.nChannels = self.nChannels + 1
131 self.nPairsEqualChannels = self.nPairsEqualChannels + 1 #par de canales iguales
132 132 else:
133 self.nPairs = self.nPairs + 1
133 self.nPairsUnequalChannels = self.nPairsUnequalChannels + 1 #par de canales diferentes
134 134
135 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights
136 self.pts2read_SelfSpectra = int( pts2read * self.nChannels )
137 self.pts2read_CrossSpectra = int( pts2read * self.nPairs )
138 self.pts2read_DCchannels = int( self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels )
135 pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock
136
137 self.pts2read_SelfSpectra = int( self.nPairsEqualChannels * pts2read )
138 self.pts2read_CrossSpectra = int( self.nPairsUnequalChannels * pts2read )
139 self.pts2read_DCchannels = int( self.m_SystemHeader.numChannels * self.m_ProcessingHeader.numHeights )
139 140
140 141 self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
141 142
142 self.m_DataObj.nChannels = self.nChannels
143 self.m_DataObj.nPairs = self.nPairs
143 self.m_DataObj.nPairsEqualChannels = self.nPairsEqualChannels
144 self.m_DataObj.nPairsUnequalChannels = self.nPairsUnequalChannels
144 145
145 146
146 147 def readBlock(self):
147 148 """
148 149 Lee el bloque de datos desde la posicion actual del puntero del archivo
149 150 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
150 151 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
151 152 es seteado a 0
152 153
153 154 Return: None
154 155
155 156 Variables afectadas:
156 157 self.datablockIndex
157 158 self.flagIsNewFile
158 159 self.flagIsNewBlock
159 160 self.nReadBlocks
160 161 self.data_spc
161 162 self.data_cspc
162 163 self.data_dc
163 164
164 165 Exceptions:
165 166 Si un bloque leido no es un bloque valido
166 167 """
167 168 blockOk_flag = False
168 169 fpointer = self.fp.tell()
169 170
170 171 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
171 172 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
172 173 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
173 174
174 175 if self.online:
175 176 if (spc.size + cspc.size + dc.size) != self.blocksize:
176 177 for nTries in range( self.nTries ):
177 178 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
178 179 time.sleep( self.delay )
179 180 self.fp.seek( fpointer )
180 181 fpointer = self.fp.tell()
181 182 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
182 183 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
183 184 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
184 185
185 186 if (spc.size + cspc.size + dc.size) == self.blocksize:
186 187 blockOk_flag = True
187 188 break
188 189 if not( blockOk_flag ):
189 190 return 0
190 191
191 192 try:
192 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
193 cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
193 spc = spc.reshape( (self.nPairsEqualChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
194 cspc = cspc.reshape( (self.nPairsUnequalChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
194 195 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
195 196 except:
196 197 print "Data file %s is invalid" % self.filename
197 198 return 0
198 199
199 200 if not( self.m_ProcessingHeader.shif_fft ):
200 201 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
201 202 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
202 203
203 204 # spc = numpy.transpose( spc, (0,2,1) )
204 205 # cspc = numpy.transpose( cspc, (0,2,1) )
205 206 #dc = numpy.transpose(dc, (0,2,1))
206 207
207 208 self.data_spc = spc
208 209 self.data_cspc = cspc['real'] + cspc['imag']*1j
209 210 self.data_dc = dc['real'] + dc['imag']*1j
210 211
211 212 self.datablockIndex = 0
212 213 self.flagIsNewFile = 0
213 214 self.flagIsNewBlock = 1
214 215
215 216 self.nReadBlocks += 1
216 217 self.nBlocks += 1
217 218
218 219 return 1
219 220
220 221
221 222 def getData(self):
222 223 """
223 224 Copia el buffer de lectura a la clase "Spectra",
224 225 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
225 226 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
226 227
227 228 Return:
228 229 0 : Si no hay mas archivos disponibles
229 230 1 : Si hizo una buena copia del buffer
230 231
231 232 Affected:
232 233 self.m_DataObj
233 234 self.datablockIndex
234 235 self.flagResetProcessing
235 236 self.flagIsNewBlock
236 237 """
237 238
238 239 if self.flagNoMoreFiles: return 0
239 240
240 241 self.flagResetProcessing = 0
241 242 self.flagIsNewBlock = 0
242 243
243 244 if self.__hasNotDataInBuffer():
244 245
245 246 if not( self.readNextBlock() ):
246 247 self.setNextFile()
247 248 return 0
248 249
249 250 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
250 251 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
251 252 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
252 253 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
253 254 self.m_DataObj.heights = self.heights
254 255 self.m_DataObj.dataType = self.dataType
255 256
256 257 if self.flagNoMoreFiles == 1:
257 258 print 'Process finished'
258 259 return 0
259 260
260 261 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
261 262
262 263 if self.data_dc == None:
263 264 self.m_DataObj.flagNoData = True
264 265 return 0
265 266
266 267 self.m_DataObj.flagNoData = False
267 268 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
268 269
269 270 self.m_DataObj.data_spc = self.data_spc
270 271 self.m_DataObj.data_cspc = self.data_cspc
271 272 self.m_DataObj.data_dc = self.data_dc
272 273
273 274 #call setData - to Data Object
274 275 #self.datablockIndex += 1
275 276 #self.idProfile += 1
276 277
277 278 return 1
278 279
279 280
280 281 class SpectraWriter(JRODataWriter):
281 282
282 283 """
283 284 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
284 285 de los datos siempre se realiza por bloques.
285 286 """
286 287
287 288 m_DataObj = None
288 289
289 290 ext = ".pdata"
290 291
291 292 optchar = "P"
292 293
293 294 shape_spc_Buffer = None
294 295 shape_cspc_Buffer = None
295 296 shape_dc_Buffer = None
296 297
297 298
298 299 def __init__(self, m_Spectra=None):
299 300 """
300 301 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
301 302
302 303 Affected:
303 304 self.m_DataObj
304 305 self.m_BasicHeader
305 306 self.m_SystemHeader
306 307 self.m_RadarControllerHeader
307 308 self.m_ProcessingHeader
308 309
309 310 Return: None
310 311 """
311 312 if m_Spectra == None:
312 313 m_Spectra = Spectra()
313 314
314 315 if not( isinstance(m_Spectra, Spectra) ):
315 316 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
316 317
317 318 self.m_DataObj = m_Spectra
318 319
319 320
320 321 def hasAllDataInBuffer(self):
321 322 return 1
322 323
323 324
324 325 def setBlockDimension(self):
325 326 """
326 327 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
327 328
328 329 Affected:
329 330 self.shape_spc_Buffer
330 331 self.shape_cspc_Buffer
331 332 self.shape_dc_Buffer
332 333
333 334 Return: None
334 335 """
335 self.shape_spc_Buffer = (self.m_DataObj.nChannels,
336 self.shape_spc_Buffer = (self.m_DataObj.nPairsEqualChannels,
336 337 self.m_ProcessingHeader.numHeights,
337 338 self.m_ProcessingHeader.profilesPerBlock)
338 339
339 self.shape_cspc_Buffer = (self.m_DataObj.nPairs,
340 self.shape_cspc_Buffer = (self.m_DataObj.nPairsUnequalChannels,
340 341 self.m_ProcessingHeader.numHeights,
341 342 self.m_ProcessingHeader.profilesPerBlock)
342 343
343 344 self.shape_dc_Buffer = (self.m_SystemHeader.numChannels,
344 345 self.m_ProcessingHeader.numHeights)
345 346
346 347
347 348 def writeBlock(self):
348 349 """
349 350 Escribe el buffer en el file designado
350 351
351 352 Affected:
352 353 self.data_spc
353 354 self.data_cspc
354 355 self.data_dc
355 356 self.flagIsNewFile
356 357 self.flagIsNewBlock
357 358 self.nWriteBlocks
358 359 self.blocksCounter
359 360
360 361 Return: None
361 362 """
362 363 spc = self.data_spc
363 364 # spc = numpy.transpose( self.data_spc, (0,2,1) )
364 365 if not( self.m_ProcessingHeader.shif_fft ):
365 366 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
366 367 data = spc.reshape((-1))
367 368 data.tofile(self.fp)
368 369
369 370 data = numpy.zeros( self.shape_cspc_Buffer, self.dataType )
370 371 cspc = self.data_cspc
371 372 # cspc = numpy.transpose( self.data_cspc, (0,2,1) )
372 373 if not( self.m_ProcessingHeader.shif_fft ):
373 374 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
374 375 data['real'] = cspc.real
375 376 data['imag'] = cspc.imag
376 377 data = data.reshape((-1))
377 378 data.tofile(self.fp)
378 379
379 380 data = numpy.zeros( self.shape_dc_Buffer, self.dataType )
380 381 dc = self.data_dc
381 382 data['real'] = dc.real
382 383 data['imag'] = dc.imag
383 384 data = data.reshape((-1))
384 385 data.tofile(self.fp)
385 386
386 387 self.data_spc.fill(0)
387 388 self.data_cspc.fill(0)
388 389 self.data_dc.fill(0)
389 390
390 391 self.flagIsNewFile = 0
391 392 self.flagIsNewBlock = 1
392 393 self.nWriteBlocks += 1
393 394 self.blocksCounter += 1
394 395
395 396
396 397 def putData(self):
397 398 """
398 399 Setea un bloque de datos y luego los escribe en un file
399 400
400 401 Affected:
401 402 self.data_spc
402 403 self.data_cspc
403 404 self.data_dc
404 405
405 406 Return:
406 407 0 : Si no hay data o no hay mas files que puedan escribirse
407 408 1 : Si se escribio la data de un bloque en un file
408 409 """
409 410 self.flagIsNewBlock = 0
410 411
411 412 if self.m_DataObj.flagNoData:
412 413 return 0
413 414
414 415 if self.m_DataObj.flagResetProcessing:
415 416 self.data_spc.fill(0)
416 417 self.data_cspc.fill(0)
417 418 self.data_dc.fill(0)
418 419 self.setNextFile()
419 420
420 421 self.data_spc = self.m_DataObj.data_spc
421 422 self.data_cspc = self.m_DataObj.data_cspc
422 423 self.data_dc = self.m_DataObj.data_dc
423 424
424 425 # #self.m_ProcessingHeader.dataBlocksPerFile)
425 426 if True:
426 427 self.getHeader()
427 428 self.writeNextBlock()
428 429
429 430 if self.flagNoMoreFiles:
430 431 #print 'Process finished'
431 432 return 0
432 433
433 434 return 1 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now