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