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