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