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