##// END OF EJS Templates
schain
RSS
Fix save spectra
Juan C. Espinoza -
r1225:7663a99dc56e
parent child
Show More
Side by Side Unified
Context file:
r1225:7663a99dc56e Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,678 +1,678
1 '''
1 '''
2 Created on Jul 2, 2014
2 Created on Jul 2, 2014
3
3
4 @author: roj-idl71
4 @author: roj-idl71
5 '''
5 '''
6 import numpy
6 import numpy
7
7
8 from schainpy.model.io.jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
8 from schainpy.model.io.jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
9 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
9 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
10 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
10 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
11 from schainpy.model.data.jrodata import Spectra
11 from schainpy.model.data.jrodata import Spectra
12 from schainpy.utils import log
12 from schainpy.utils import log
13
13
14 @MPDecorator
14 @MPDecorator
15 class SpectraReader(JRODataReader, ProcessingUnit):
15 class SpectraReader(JRODataReader, ProcessingUnit):
16 """
16 """
17 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
17 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
18 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
18 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
19 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
19 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
20
20
21 paresCanalesIguales * alturas * perfiles (Self Spectra)
21 paresCanalesIguales * alturas * perfiles (Self Spectra)
22 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
22 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
23 canales * alturas (DC Channels)
23 canales * alturas (DC Channels)
24
24
25 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
25 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
26 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
26 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
27 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
27 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
28 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
28 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
29
29
30 Example:
30 Example:
31 dpath = "/home/myuser/data"
31 dpath = "/home/myuser/data"
32
32
33 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
33 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
34
34
35 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
35 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
36
36
37 readerObj = SpectraReader()
37 readerObj = SpectraReader()
38
38
39 readerObj.setup(dpath, startTime, endTime)
39 readerObj.setup(dpath, startTime, endTime)
40
40
41 while(True):
41 while(True):
42
42
43 readerObj.getData()
43 readerObj.getData()
44
44
45 print readerObj.data_spc
45 print readerObj.data_spc
46
46
47 print readerObj.data_cspc
47 print readerObj.data_cspc
48
48
49 print readerObj.data_dc
49 print readerObj.data_dc
50
50
51 if readerObj.flagNoMoreFiles:
51 if readerObj.flagNoMoreFiles:
52 break
52 break
53
53
54 """
54 """
55
55
56 pts2read_SelfSpectra = 0
56 pts2read_SelfSpectra = 0
57
57
58 pts2read_CrossSpectra = 0
58 pts2read_CrossSpectra = 0
59
59
60 pts2read_DCchannels = 0
60 pts2read_DCchannels = 0
61
61
62 ext = ".pdata"
62 ext = ".pdata"
63
63
64 optchar = "P"
64 optchar = "P"
65
65
66 dataOut = None
66 dataOut = None
67
67
68 nRdChannels = None
68 nRdChannels = None
69
69
70 nRdPairs = None
70 nRdPairs = None
71
71
72 rdPairList = []
72 rdPairList = []
73
73
74 def __init__(self):#, **kwargs):
74 def __init__(self):#, **kwargs):
75 """
75 """
76 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
76 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
77
77
78 Inputs:
78 Inputs:
79 dataOut : Objeto de la clase Spectra. Este objeto sera utilizado para
79 dataOut : Objeto de la clase Spectra. Este objeto sera utilizado para
80 almacenar un perfil de datos cada vez que se haga un requerimiento
80 almacenar un perfil de datos cada vez que se haga un requerimiento
81 (getData). El perfil sera obtenido a partir del buffer de datos,
81 (getData). El perfil sera obtenido a partir del buffer de datos,
82 si el buffer esta vacio se hara un nuevo proceso de lectura de un
82 si el buffer esta vacio se hara un nuevo proceso de lectura de un
83 bloque de datos.
83 bloque de datos.
84 Si este parametro no es pasado se creara uno internamente.
84 Si este parametro no es pasado se creara uno internamente.
85
85
86 Affected:
86 Affected:
87 self.dataOut
87 self.dataOut
88
88
89 Return : None
89 Return : None
90 """
90 """
91
91
92 #Eliminar de la base la herencia
92 #Eliminar de la base la herencia
93 ProcessingUnit.__init__(self)#, **kwargs)
93 ProcessingUnit.__init__(self)#, **kwargs)
94
94
95 # self.isConfig = False
95 # self.isConfig = False
96
96
97 self.pts2read_SelfSpectra = 0
97 self.pts2read_SelfSpectra = 0
98
98
99 self.pts2read_CrossSpectra = 0
99 self.pts2read_CrossSpectra = 0
100
100
101 self.pts2read_DCchannels = 0
101 self.pts2read_DCchannels = 0
102
102
103 self.datablock = None
103 self.datablock = None
104
104
105 self.utc = None
105 self.utc = None
106
106
107 self.ext = ".pdata"
107 self.ext = ".pdata"
108
108
109 self.optchar = "P"
109 self.optchar = "P"
110
110
111 self.basicHeaderObj = BasicHeader(LOCALTIME)
111 self.basicHeaderObj = BasicHeader(LOCALTIME)
112
112
113 self.systemHeaderObj = SystemHeader()
113 self.systemHeaderObj = SystemHeader()
114
114
115 self.radarControllerHeaderObj = RadarControllerHeader()
115 self.radarControllerHeaderObj = RadarControllerHeader()
116
116
117 self.processingHeaderObj = ProcessingHeader()
117 self.processingHeaderObj = ProcessingHeader()
118
118
119 self.online = 0
119 self.online = 0
120
120
121 self.fp = None
121 self.fp = None
122
122
123 self.idFile = None
123 self.idFile = None
124
124
125 self.dtype = None
125 self.dtype = None
126
126
127 self.fileSizeByHeader = None
127 self.fileSizeByHeader = None
128
128
129 self.filenameList = []
129 self.filenameList = []
130
130
131 self.filename = None
131 self.filename = None
132
132
133 self.fileSize = None
133 self.fileSize = None
134
134
135 self.firstHeaderSize = 0
135 self.firstHeaderSize = 0
136
136
137 self.basicHeaderSize = 24
137 self.basicHeaderSize = 24
138
138
139 self.pathList = []
139 self.pathList = []
140
140
141 self.lastUTTime = 0
141 self.lastUTTime = 0
142
142
143 self.maxTimeStep = 30
143 self.maxTimeStep = 30
144
144
145 self.flagNoMoreFiles = 0
145 self.flagNoMoreFiles = 0
146
146
147 self.set = 0
147 self.set = 0
148
148
149 self.path = None
149 self.path = None
150
150
151 self.delay = 60 #seconds
151 self.delay = 60 #seconds
152
152
153 self.nTries = 3 #quantity tries
153 self.nTries = 3 #quantity tries
154
154
155 self.nFiles = 3 #number of files for searching
155 self.nFiles = 3 #number of files for searching
156
156
157 self.nReadBlocks = 0
157 self.nReadBlocks = 0
158
158
159 self.flagIsNewFile = 1
159 self.flagIsNewFile = 1
160
160
161 self.__isFirstTimeOnline = 1
161 self.__isFirstTimeOnline = 1
162
162
163 # self.ippSeconds = 0
163 # self.ippSeconds = 0
164
164
165 self.flagDiscontinuousBlock = 0
165 self.flagDiscontinuousBlock = 0
166
166
167 self.flagIsNewBlock = 0
167 self.flagIsNewBlock = 0
168
168
169 self.nTotalBlocks = 0
169 self.nTotalBlocks = 0
170
170
171 self.blocksize = 0
171 self.blocksize = 0
172
172
173 self.dataOut = self.createObjByDefault()
173 self.dataOut = self.createObjByDefault()
174
174
175 self.profileIndex = 1 #Always
175 self.profileIndex = 1 #Always
176
176
177
177
178 def createObjByDefault(self):
178 def createObjByDefault(self):
179
179
180 dataObj = Spectra()
180 dataObj = Spectra()
181
181
182 return dataObj
182 return dataObj
183
183
184 def __hasNotDataInBuffer(self):
184 def __hasNotDataInBuffer(self):
185 return 1
185 return 1
186
186
187
187
188 def getBlockDimension(self):
188 def getBlockDimension(self):
189 """
189 """
190 Obtiene la cantidad de puntos a leer por cada bloque de datos
190 Obtiene la cantidad de puntos a leer por cada bloque de datos
191
191
192 Affected:
192 Affected:
193 self.nRdChannels
193 self.nRdChannels
194 self.nRdPairs
194 self.nRdPairs
195 self.pts2read_SelfSpectra
195 self.pts2read_SelfSpectra
196 self.pts2read_CrossSpectra
196 self.pts2read_CrossSpectra
197 self.pts2read_DCchannels
197 self.pts2read_DCchannels
198 self.blocksize
198 self.blocksize
199 self.dataOut.nChannels
199 self.dataOut.nChannels
200 self.dataOut.nPairs
200 self.dataOut.nPairs
201
201
202 Return:
202 Return:
203 None
203 None
204 """
204 """
205 self.nRdChannels = 0
205 self.nRdChannels = 0
206 self.nRdPairs = 0
206 self.nRdPairs = 0
207 self.rdPairList = []
207 self.rdPairList = []
208
208
209 for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
209 for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
210 if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
210 if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
211 self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
211 self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
212 else:
212 else:
213 self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
213 self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
214 self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
214 self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
215
215
216 pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
216 pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
217
217
218 self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
218 self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
219 self.blocksize = self.pts2read_SelfSpectra
219 self.blocksize = self.pts2read_SelfSpectra
220
220
221 if self.processingHeaderObj.flag_cspc:
221 if self.processingHeaderObj.flag_cspc:
222 self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
222 self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
223 self.blocksize += self.pts2read_CrossSpectra
223 self.blocksize += self.pts2read_CrossSpectra
224
224
225 if self.processingHeaderObj.flag_dc:
225 if self.processingHeaderObj.flag_dc:
226 self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
226 self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
227 self.blocksize += self.pts2read_DCchannels
227 self.blocksize += self.pts2read_DCchannels
228
228
229 # self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
229 # self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
230
230
231
231
232 def readBlock(self):
232 def readBlock(self):
233 """
233 """
234 Lee el bloque de datos desde la posicion actual del puntero del archivo
234 Lee el bloque de datos desde la posicion actual del puntero del archivo
235 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
235 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
236 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
236 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
237 es seteado a 0
237 es seteado a 0
238
238
239 Return: None
239 Return: None
240
240
241 Variables afectadas:
241 Variables afectadas:
242
242
243 self.flagIsNewFile
243 self.flagIsNewFile
244 self.flagIsNewBlock
244 self.flagIsNewBlock
245 self.nTotalBlocks
245 self.nTotalBlocks
246 self.data_spc
246 self.data_spc
247 self.data_cspc
247 self.data_cspc
248 self.data_dc
248 self.data_dc
249
249
250 Exceptions:
250 Exceptions:
251 Si un bloque leido no es un bloque valido
251 Si un bloque leido no es un bloque valido
252 """
252 """
253 blockOk_flag = False
253 blockOk_flag = False
254 fpointer = self.fp.tell()
254 fpointer = self.fp.tell()
255
255
256 spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
256 spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
257 spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
257 spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
258
258
259 if self.processingHeaderObj.flag_cspc:
259 if self.processingHeaderObj.flag_cspc:
260 cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
260 cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
261 cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
261 cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
262
262
263 if self.processingHeaderObj.flag_dc:
263 if self.processingHeaderObj.flag_dc:
264 dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
264 dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
265 dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
265 dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
266
266
267
267
268 if not self.processingHeaderObj.shif_fft:
268 if not self.processingHeaderObj.shif_fft:
269 #desplaza a la derecha en el eje 2 determinadas posiciones
269 #desplaza a la derecha en el eje 2 determinadas posiciones
270 shift = int(self.processingHeaderObj.profilesPerBlock/2)
270 shift = int(self.processingHeaderObj.profilesPerBlock/2)
271 spc = numpy.roll( spc, shift , axis=2 )
271 spc = numpy.roll( spc, shift , axis=2 )
272
272
273 if self.processingHeaderObj.flag_cspc:
273 if self.processingHeaderObj.flag_cspc:
274 #desplaza a la derecha en el eje 2 determinadas posiciones
274 #desplaza a la derecha en el eje 2 determinadas posiciones
275 cspc = numpy.roll( cspc, shift, axis=2 )
275 cspc = numpy.roll( cspc, shift, axis=2 )
276
276
277 #Dimensions : nChannels, nProfiles, nSamples
277 #Dimensions : nChannels, nProfiles, nSamples
278 spc = numpy.transpose( spc, (0,2,1) )
278 spc = numpy.transpose( spc, (0,2,1) )
279 self.data_spc = spc
279 self.data_spc = spc
280
280
281 if self.processingHeaderObj.flag_cspc:
281 if self.processingHeaderObj.flag_cspc:
282 cspc = numpy.transpose( cspc, (0,2,1) )
282 cspc = numpy.transpose( cspc, (0,2,1) )
283 self.data_cspc = cspc['real'] + cspc['imag']*1j
283 self.data_cspc = cspc['real'] + cspc['imag']*1j
284 else:
284 else:
285 self.data_cspc = None
285 self.data_cspc = None
286
286
287 if self.processingHeaderObj.flag_dc:
287 if self.processingHeaderObj.flag_dc:
288 self.data_dc = dc['real'] + dc['imag']*1j
288 self.data_dc = dc['real'] + dc['imag']*1j
289 else:
289 else:
290 self.data_dc = None
290 self.data_dc = None
291
291
292 self.flagIsNewFile = 0
292 self.flagIsNewFile = 0
293 self.flagIsNewBlock = 1
293 self.flagIsNewBlock = 1
294
294
295 self.nTotalBlocks += 1
295 self.nTotalBlocks += 1
296 self.nReadBlocks += 1
296 self.nReadBlocks += 1
297
297
298 return 1
298 return 1
299
299
300 def getFirstHeader(self):
300 def getFirstHeader(self):
301
301
302 self.getBasicHeader()
302 self.getBasicHeader()
303
303
304 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
304 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
305
305
306 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
306 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
307
307
308 # self.dataOut.ippSeconds = self.ippSeconds
308 # self.dataOut.ippSeconds = self.ippSeconds
309
309
310 # self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.processingHeaderObj.profilesPerBlock
310 # self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.processingHeaderObj.profilesPerBlock
311
311
312 self.dataOut.dtype = self.dtype
312 self.dataOut.dtype = self.dtype
313
313
314 # self.dataOut.nPairs = self.nPairs
314 # self.dataOut.nPairs = self.nPairs
315
315
316 self.dataOut.pairsList = self.rdPairList
316 self.dataOut.pairsList = self.rdPairList
317
317
318 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
318 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
319
319
320 self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
320 self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
321
321
322 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
322 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
323
323
324 self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
324 self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
325
325
326 xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
326 xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
327
327
328 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
328 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
329
329
330 self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
330 self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
331
331
332 self.dataOut.flagShiftFFT = True #Data is always shifted
332 self.dataOut.flagShiftFFT = True #Data is always shifted
333
333
334 self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
334 self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
335
335
336 self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data esta sin flip
336 self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data esta sin flip
337
337
338 def getData(self):
338 def getData(self):
339 """
339 """
340 First method to execute before "RUN" is called.
340 First method to execute before "RUN" is called.
341
341
342 Copia el buffer de lectura a la clase "Spectra",
342 Copia el buffer de lectura a la clase "Spectra",
343 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
343 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
344 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
344 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
345
345
346 Return:
346 Return:
347 0 : Si no hay mas archivos disponibles
347 0 : Si no hay mas archivos disponibles
348 1 : Si hizo una buena copia del buffer
348 1 : Si hizo una buena copia del buffer
349
349
350 Affected:
350 Affected:
351 self.dataOut
351 self.dataOut
352
352
353 self.flagDiscontinuousBlock
353 self.flagDiscontinuousBlock
354 self.flagIsNewBlock
354 self.flagIsNewBlock
355 """
355 """
356
356
357 if self.flagNoMoreFiles:
357 if self.flagNoMoreFiles:
358 self.dataOut.flagNoData = True
358 self.dataOut.flagNoData = True
359 print('Process finished')
359 print('Process finished')
360 return 0
360 return 0
361
361
362 self.flagDiscontinuousBlock = 0
362 self.flagDiscontinuousBlock = 0
363 self.flagIsNewBlock = 0
363 self.flagIsNewBlock = 0
364
364
365 if self.__hasNotDataInBuffer():
365 if self.__hasNotDataInBuffer():
366
366
367 if not( self.readNextBlock() ):
367 if not( self.readNextBlock() ):
368 self.dataOut.flagNoData = True
368 self.dataOut.flagNoData = True
369 return 0
369 return 0
370
370
371 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
371 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
372
372
373 if self.data_spc is None:
373 if self.data_spc is None:
374 self.dataOut.flagNoData = True
374 self.dataOut.flagNoData = True
375 return 0
375 return 0
376
376
377 self.getBasicHeader()
377 self.getBasicHeader()
378
378
379 self.getFirstHeader()
379 self.getFirstHeader()
380
380
381 self.dataOut.data_spc = self.data_spc
381 self.dataOut.data_spc = self.data_spc
382
382
383 self.dataOut.data_cspc = self.data_cspc
383 self.dataOut.data_cspc = self.data_cspc
384
384
385 self.dataOut.data_dc = self.data_dc
385 self.dataOut.data_dc = self.data_dc
386
386
387 self.dataOut.flagNoData = False
387 self.dataOut.flagNoData = False
388
388
389 self.dataOut.realtime = self.online
389 self.dataOut.realtime = self.online
390
390
391 return self.dataOut.data_spc
391 return self.dataOut.data_spc
392 @MPDecorator
392 @MPDecorator
393 class SpectraWriter(JRODataWriter, Operation):
393 class SpectraWriter(JRODataWriter, Operation):
394
394
395 """
395 """
396 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
396 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
397 de los datos siempre se realiza por bloques.
397 de los datos siempre se realiza por bloques.
398 """
398 """
399
399
400 ext = ".pdata"
400 ext = ".pdata"
401
401
402 optchar = "P"
402 optchar = "P"
403
403
404 shape_spc_Buffer = None
404 shape_spc_Buffer = None
405
405
406 shape_cspc_Buffer = None
406 shape_cspc_Buffer = None
407
407
408 shape_dc_Buffer = None
408 shape_dc_Buffer = None
409
409
410 data_spc = None
410 data_spc = None
411
411
412 data_cspc = None
412 data_cspc = None
413
413
414 data_dc = None
414 data_dc = None
415
415
416 def __init__(self):
416 def __init__(self):
417 """
417 """
418 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
418 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
419
419
420 Affected:
420 Affected:
421 self.dataOut
421 self.dataOut
422 self.basicHeaderObj
422 self.basicHeaderObj
423 self.systemHeaderObj
423 self.systemHeaderObj
424 self.radarControllerHeaderObj
424 self.radarControllerHeaderObj
425 self.processingHeaderObj
425 self.processingHeaderObj
426
426
427 Return: None
427 Return: None
428 """
428 """
429
429
430 Operation.__init__(self)
430 Operation.__init__(self)
431
431
432 self.nTotalBlocks = 0
432 self.nTotalBlocks = 0
433
433
434 self.data_spc = None
434 self.data_spc = None
435
435
436 self.data_cspc = None
436 self.data_cspc = None
437
437
438 self.data_dc = None
438 self.data_dc = None
439
439
440 self.fp = None
440 self.fp = None
441
441
442 self.flagIsNewFile = 1
442 self.flagIsNewFile = 1
443
443
444 self.nTotalBlocks = 0
444 self.nTotalBlocks = 0
445
445
446 self.flagIsNewBlock = 0
446 self.flagIsNewBlock = 0
447
447
448 self.setFile = None
448 self.setFile = None
449
449
450 self.dtype = None
450 self.dtype = None
451
451
452 self.path = None
452 self.path = None
453
453
454 self.noMoreFiles = 0
454 self.noMoreFiles = 0
455
455
456 self.filename = None
456 self.filename = None
457
457
458 self.basicHeaderObj = BasicHeader(LOCALTIME)
458 self.basicHeaderObj = BasicHeader(LOCALTIME)
459
459
460 self.systemHeaderObj = SystemHeader()
460 self.systemHeaderObj = SystemHeader()
461
461
462 self.radarControllerHeaderObj = RadarControllerHeader()
462 self.radarControllerHeaderObj = RadarControllerHeader()
463
463
464 self.processingHeaderObj = ProcessingHeader()
464 self.processingHeaderObj = ProcessingHeader()
465
465
466
466
467 def hasAllDataInBuffer(self):
467 def hasAllDataInBuffer(self):
468 return 1
468 return 1
469
469
470
470
471 def setBlockDimension(self):
471 def setBlockDimension(self):
472 """
472 """
473 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
473 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
474
474
475 Affected:
475 Affected:
476 self.shape_spc_Buffer
476 self.shape_spc_Buffer
477 self.shape_cspc_Buffer
477 self.shape_cspc_Buffer
478 self.shape_dc_Buffer
478 self.shape_dc_Buffer
479
479
480 Return: None
480 Return: None
481 """
481 """
482 self.shape_spc_Buffer = (self.dataOut.nChannels,
482 self.shape_spc_Buffer = (self.dataOut.nChannels,
483 self.processingHeaderObj.nHeights,
483 self.processingHeaderObj.nHeights,
484 self.processingHeaderObj.profilesPerBlock)
484 self.processingHeaderObj.profilesPerBlock)
485
485
486 self.shape_cspc_Buffer = (self.dataOut.nPairs,
486 self.shape_cspc_Buffer = (self.dataOut.nPairs,
487 self.processingHeaderObj.nHeights,
487 self.processingHeaderObj.nHeights,
488 self.processingHeaderObj.profilesPerBlock)
488 self.processingHeaderObj.profilesPerBlock)
489
489
490 self.shape_dc_Buffer = (self.dataOut.nChannels,
490 self.shape_dc_Buffer = (self.dataOut.nChannels,
491 self.processingHeaderObj.nHeights)
491 self.processingHeaderObj.nHeights)
492
492
493
493
494 def writeBlock(self):
494 def writeBlock(self):
495 """processingHeaderObj
495 """processingHeaderObj
496 Escribe el buffer en el file designado
496 Escribe el buffer en el file designado
497
497
498 Affected:
498 Affected:
499 self.data_spc
499 self.data_spc
500 self.data_cspc
500 self.data_cspc
501 self.data_dc
501 self.data_dc
502 self.flagIsNewFile
502 self.flagIsNewFile
503 self.flagIsNewBlock
503 self.flagIsNewBlock
504 self.nTotalBlocks
504 self.nTotalBlocks
505 self.nWriteBlocks
505 self.nWriteBlocks
506
506
507 Return: None
507 Return: None
508 """
508 """
509
509
510 spc = numpy.transpose( self.data_spc, (0,2,1) )
510 spc = numpy.transpose( self.data_spc, (0,2,1) )
511 if not self.processingHeaderObj.shif_fft:
511 if not self.processingHeaderObj.shif_fft:
512 spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
512 spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
513 data = spc.reshape((-1))
513 data = spc.reshape((-1))
514 data = data.astype(self.dtype[0])
514 data = data.astype(self.dtype[0])
515 data.tofile(self.fp)
515 data.tofile(self.fp)
516
516
517 if self.data_cspc is not None:
517 if self.data_cspc is not None:
518
518
519 cspc = numpy.transpose( self.data_cspc, (0,2,1) )
519 cspc = numpy.transpose( self.data_cspc, (0,2,1) )
520 #data = numpy.zeros( numpy.shape(cspc), self.dtype )
520 data = numpy.zeros( numpy.shape(cspc), self.dtype )
521 #print 'data.shape', self.shape_cspc_Buffer
521 #print 'data.shape', self.shape_cspc_Buffer
522 if not self.processingHeaderObj.shif_fft:
522 if not self.processingHeaderObj.shif_fft:
523 cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
523 cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
524 data['real'] = cspc.real
524 data['real'] = cspc.real
525 data['imag'] = cspc.imag
525 data['imag'] = cspc.imag
526 data = data.reshape((-1))
526 data = data.reshape((-1))
527 data.tofile(self.fp)
527 data.tofile(self.fp)
528
528
529 if self.data_dc is not None:
529 if self.data_dc is not None:
530
530
531 dc = self.data_dc
531 dc = self.data_dc
532 data = numpy.zeros( numpy.shape(dc), self.dtype )
532 data = numpy.zeros( numpy.shape(dc), self.dtype )
533 data['real'] = dc.real
533 data['real'] = dc.real
534 data['imag'] = dc.imag
534 data['imag'] = dc.imag
535 data = data.reshape((-1))
535 data = data.reshape((-1))
536 data.tofile(self.fp)
536 data.tofile(self.fp)
537
537
538 # self.data_spc.fill(0)
538 # self.data_spc.fill(0)
539 #
539 #
540 # if self.data_dc is not None:
540 # if self.data_dc is not None:
541 # self.data_dc.fill(0)
541 # self.data_dc.fill(0)
542 #
542 #
543 # if self.data_cspc is not None:
543 # if self.data_cspc is not None:
544 # self.data_cspc.fill(0)
544 # self.data_cspc.fill(0)
545
545
546 self.flagIsNewFile = 0
546 self.flagIsNewFile = 0
547 self.flagIsNewBlock = 1
547 self.flagIsNewBlock = 1
548 self.nTotalBlocks += 1
548 self.nTotalBlocks += 1
549 self.nWriteBlocks += 1
549 self.nWriteBlocks += 1
550 self.blockIndex += 1
550 self.blockIndex += 1
551
551
552 # print "[Writing] Block = %d04" %self.blockIndex
552 # print "[Writing] Block = %d04" %self.blockIndex
553
553
554 def putData(self):
554 def putData(self):
555 """
555 """
556 Setea un bloque de datos y luego los escribe en un file
556 Setea un bloque de datos y luego los escribe en un file
557
557
558 Affected:
558 Affected:
559 self.data_spc
559 self.data_spc
560 self.data_cspc
560 self.data_cspc
561 self.data_dc
561 self.data_dc
562
562
563 Return:
563 Return:
564 0 : Si no hay data o no hay mas files que puedan escribirse
564 0 : Si no hay data o no hay mas files que puedan escribirse
565 1 : Si se escribio la data de un bloque en un file
565 1 : Si se escribio la data de un bloque en un file
566 """
566 """
567
567
568 if self.dataOut.flagNoData:
568 if self.dataOut.flagNoData:
569 return 0
569 return 0
570
570
571 self.flagIsNewBlock = 0
571 self.flagIsNewBlock = 0
572
572
573 if self.dataOut.flagDiscontinuousBlock:
573 if self.dataOut.flagDiscontinuousBlock:
574 self.data_spc.fill(0)
574 self.data_spc.fill(0)
575 if self.dataOut.data_cspc is not None:
575 if self.dataOut.data_cspc is not None:
576 self.data_cspc.fill(0)
576 self.data_cspc.fill(0)
577 if self.dataOut.data_dc is not None:
577 if self.dataOut.data_dc is not None:
578 self.data_dc.fill(0)
578 self.data_dc.fill(0)
579 self.setNextFile()
579 self.setNextFile()
580
580
581 if self.flagIsNewFile == 0:
581 if self.flagIsNewFile == 0:
582 self.setBasicHeader()
582 self.setBasicHeader()
583
583
584 self.data_spc = self.dataOut.data_spc.copy()
584 self.data_spc = self.dataOut.data_spc.copy()
585
585
586 if self.dataOut.data_cspc is not None:
586 if self.dataOut.data_cspc is not None:
587 self.data_cspc = self.dataOut.data_cspc.copy()
587 self.data_cspc = self.dataOut.data_cspc.copy()
588
588
589 if self.dataOut.data_dc is not None:
589 if self.dataOut.data_dc is not None:
590 self.data_dc = self.dataOut.data_dc.copy()
590 self.data_dc = self.dataOut.data_dc.copy()
591
591
592 # #self.processingHeaderObj.dataBlocksPerFile)
592 # #self.processingHeaderObj.dataBlocksPerFile)
593 if self.hasAllDataInBuffer():
593 if self.hasAllDataInBuffer():
594 # self.setFirstHeader()
594 # self.setFirstHeader()
595 self.writeNextBlock()
595 self.writeNextBlock()
596
596
597 def __getBlockSize(self):
597 def __getBlockSize(self):
598 '''
598 '''
599 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
599 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
600 '''
600 '''
601
601
602 dtype_width = self.getDtypeWidth()
602 dtype_width = self.getDtypeWidth()
603
603
604 pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
604 pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
605
605
606 pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
606 pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
607 blocksize = (pts2write_SelfSpectra*dtype_width)
607 blocksize = (pts2write_SelfSpectra*dtype_width)
608
608
609 if self.dataOut.data_cspc is not None:
609 if self.dataOut.data_cspc is not None:
610 pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
610 pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
611 blocksize += (pts2write_CrossSpectra*dtype_width*2)
611 blocksize += (pts2write_CrossSpectra*dtype_width*2)
612
612
613 if self.dataOut.data_dc is not None:
613 if self.dataOut.data_dc is not None:
614 pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
614 pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
615 blocksize += (pts2write_DCchannels*dtype_width*2)
615 blocksize += (pts2write_DCchannels*dtype_width*2)
616
616
617 # blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
617 # blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
618
618
619 return blocksize
619 return blocksize
620
620
621 def setFirstHeader(self):
621 def setFirstHeader(self):
622
622
623 """
623 """
624 Obtiene una copia del First Header
624 Obtiene una copia del First Header
625
625
626 Affected:
626 Affected:
627 self.systemHeaderObj
627 self.systemHeaderObj
628 self.radarControllerHeaderObj
628 self.radarControllerHeaderObj
629 self.dtype
629 self.dtype
630
630
631 Return:
631 Return:
632 None
632 None
633 """
633 """
634
634
635 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
635 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
636 self.systemHeaderObj.nChannels = self.dataOut.nChannels
636 self.systemHeaderObj.nChannels = self.dataOut.nChannels
637 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
637 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
638
638
639 self.processingHeaderObj.dtype = 1 # Spectra
639 self.processingHeaderObj.dtype = 1 # Spectra
640 self.processingHeaderObj.blockSize = self.__getBlockSize()
640 self.processingHeaderObj.blockSize = self.__getBlockSize()
641 self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
641 self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
642 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
642 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
643 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
643 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
644 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
644 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
645 self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
645 self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
646 self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
646 self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
647 self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT
647 self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT
648
648
649 if self.processingHeaderObj.totalSpectra > 0:
649 if self.processingHeaderObj.totalSpectra > 0:
650 channelList = []
650 channelList = []
651 for channel in range(self.dataOut.nChannels):
651 for channel in range(self.dataOut.nChannels):
652 channelList.append(channel)
652 channelList.append(channel)
653 channelList.append(channel)
653 channelList.append(channel)
654
654
655 pairsList = []
655 pairsList = []
656 if self.dataOut.nPairs > 0:
656 if self.dataOut.nPairs > 0:
657 for pair in self.dataOut.pairsList:
657 for pair in self.dataOut.pairsList:
658 pairsList.append(pair[0])
658 pairsList.append(pair[0])
659 pairsList.append(pair[1])
659 pairsList.append(pair[1])
660
660
661 spectraComb = channelList + pairsList
661 spectraComb = channelList + pairsList
662 spectraComb = numpy.array(spectraComb, dtype="u1")
662 spectraComb = numpy.array(spectraComb, dtype="u1")
663 self.processingHeaderObj.spectraComb = spectraComb
663 self.processingHeaderObj.spectraComb = spectraComb
664
664
665 if self.dataOut.code is not None:
665 if self.dataOut.code is not None:
666 self.processingHeaderObj.code = self.dataOut.code
666 self.processingHeaderObj.code = self.dataOut.code
667 self.processingHeaderObj.nCode = self.dataOut.nCode
667 self.processingHeaderObj.nCode = self.dataOut.nCode
668 self.processingHeaderObj.nBaud = self.dataOut.nBaud
668 self.processingHeaderObj.nBaud = self.dataOut.nBaud
669
669
670 if self.processingHeaderObj.nWindows != 0:
670 if self.processingHeaderObj.nWindows != 0:
671 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
671 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
672 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
672 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
673 self.processingHeaderObj.nHeights = self.dataOut.nHeights
673 self.processingHeaderObj.nHeights = self.dataOut.nHeights
674 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
674 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
675
675
676 self.processingHeaderObj.processFlags = self.getProcessFlags()
676 self.processingHeaderObj.processFlags = self.getProcessFlags()
677
677
678 self.setBasicHeader() No newline at end of file
678 self.setBasicHeader()
General Comments 0
You need to be logged in to leave comments. Login now