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