##// END OF EJS Templates
schain
RSS
Support for VoltageReader when nTxs is >1 or <1
Miguel Valdez -
r748:0fab1290f1a0
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,594 +1,596
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
6
7 import numpy
7 import numpy
8
8
9 from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
9 from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
10 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
10 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
11 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
11 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
12 from schainpy.model.data.jrodata import Voltage
12 from schainpy.model.data.jrodata import Voltage
13
13
14 class VoltageReader(JRODataReader, ProcessingUnit):
14 class VoltageReader(JRODataReader, ProcessingUnit):
15 """
15 """
16 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
16 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
17 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
17 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
18 perfiles*alturas*canales) son almacenados en la variable "buffer".
18 perfiles*alturas*canales) son almacenados en la variable "buffer".
19
19
20 perfiles * alturas * canales
20 perfiles * alturas * canales
21
21
22 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
22 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
23 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
23 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
24 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
24 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
25 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
25 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
26
26
27 Example:
27 Example:
28
28
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 = VoltageReader()
35 readerObj = VoltageReader()
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 #to get one profile
41 #to get one profile
42 profile = readerObj.getData()
42 profile = readerObj.getData()
43
43
44 #print the profile
44 #print the profile
45 print profile
45 print profile
46
46
47 #If you want to see all datablock
47 #If you want to see all datablock
48 print readerObj.datablock
48 print readerObj.datablock
49
49
50 if readerObj.flagNoMoreFiles:
50 if readerObj.flagNoMoreFiles:
51 break
51 break
52
52
53 """
53 """
54
54
55 ext = ".r"
55 ext = ".r"
56
56
57 optchar = "D"
57 optchar = "D"
58 dataOut = None
58 dataOut = None
59
59
60
60
61 def __init__(self):
61 def __init__(self):
62 """
62 """
63 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
63 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
64
64
65 Input:
65 Input:
66 dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para
66 dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para
67 almacenar un perfil de datos cada vez que se haga un requerimiento
67 almacenar un perfil de datos cada vez que se haga un requerimiento
68 (getData). El perfil sera obtenido a partir del buffer de datos,
68 (getData). El perfil sera obtenido a partir del buffer de datos,
69 si el buffer esta vacio se hara un nuevo proceso de lectura de un
69 si el buffer esta vacio se hara un nuevo proceso de lectura de un
70 bloque de datos.
70 bloque de datos.
71 Si este parametro no es pasado se creara uno internamente.
71 Si este parametro no es pasado se creara uno internamente.
72
72
73 Variables afectadas:
73 Variables afectadas:
74 self.dataOut
74 self.dataOut
75
75
76 Return:
76 Return:
77 None
77 None
78 """
78 """
79
79
80 ProcessingUnit.__init__(self)
80 ProcessingUnit.__init__(self)
81
81
82 self.isConfig = False
82 self.isConfig = False
83
83
84 self.datablock = None
84 self.datablock = None
85
85
86 self.utc = 0
86 self.utc = 0
87
87
88 self.ext = ".r"
88 self.ext = ".r"
89
89
90 self.optchar = "D"
90 self.optchar = "D"
91
91
92 self.basicHeaderObj = BasicHeader(LOCALTIME)
92 self.basicHeaderObj = BasicHeader(LOCALTIME)
93
93
94 self.systemHeaderObj = SystemHeader()
94 self.systemHeaderObj = SystemHeader()
95
95
96 self.radarControllerHeaderObj = RadarControllerHeader()
96 self.radarControllerHeaderObj = RadarControllerHeader()
97
97
98 self.processingHeaderObj = ProcessingHeader()
98 self.processingHeaderObj = ProcessingHeader()
99
99
100 self.online = 0
100 self.online = 0
101
101
102 self.fp = None
102 self.fp = None
103
103
104 self.idFile = None
104 self.idFile = None
105
105
106 self.dtype = None
106 self.dtype = None
107
107
108 self.fileSizeByHeader = None
108 self.fileSizeByHeader = None
109
109
110 self.filenameList = []
110 self.filenameList = []
111
111
112 self.filename = None
112 self.filename = None
113
113
114 self.fileSize = None
114 self.fileSize = None
115
115
116 self.firstHeaderSize = 0
116 self.firstHeaderSize = 0
117
117
118 self.basicHeaderSize = 24
118 self.basicHeaderSize = 24
119
119
120 self.pathList = []
120 self.pathList = []
121
121
122 self.filenameList = []
122 self.filenameList = []
123
123
124 self.lastUTTime = 0
124 self.lastUTTime = 0
125
125
126 self.maxTimeStep = 30
126 self.maxTimeStep = 30
127
127
128 self.flagNoMoreFiles = 0
128 self.flagNoMoreFiles = 0
129
129
130 self.set = 0
130 self.set = 0
131
131
132 self.path = None
132 self.path = None
133
133
134 self.profileIndex = 2**32-1
134 self.profileIndex = 2**32-1
135
135
136 self.delay = 3 #seconds
136 self.delay = 3 #seconds
137
137
138 self.nTries = 3 #quantity tries
138 self.nTries = 3 #quantity tries
139
139
140 self.nFiles = 3 #number of files for searching
140 self.nFiles = 3 #number of files for searching
141
141
142 self.nReadBlocks = 0
142 self.nReadBlocks = 0
143
143
144 self.flagIsNewFile = 1
144 self.flagIsNewFile = 1
145
145
146 self.__isFirstTimeOnline = 1
146 self.__isFirstTimeOnline = 1
147
147
148 # self.ippSeconds = 0
148 # self.ippSeconds = 0
149
149
150 self.flagDiscontinuousBlock = 0
150 self.flagDiscontinuousBlock = 0
151
151
152 self.flagIsNewBlock = 0
152 self.flagIsNewBlock = 0
153
153
154 self.nTotalBlocks = 0
154 self.nTotalBlocks = 0
155
155
156 self.blocksize = 0
156 self.blocksize = 0
157
157
158 self.dataOut = self.createObjByDefault()
158 self.dataOut = self.createObjByDefault()
159
159
160 self.nTxs = 1
160 self.nTxs = 1
161
161
162 self.txIndex = 0
162 self.txIndex = 0
163
163
164 def createObjByDefault(self):
164 def createObjByDefault(self):
165
165
166 dataObj = Voltage()
166 dataObj = Voltage()
167
167
168 return dataObj
168 return dataObj
169
169
170 def __hasNotDataInBuffer(self):
170 def __hasNotDataInBuffer(self):
171
171
172 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
172 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock*self.nTxs:
173 return 1
173 return 1
174
174
175 return 0
175 return 0
176
176
177
177
178 def getBlockDimension(self):
178 def getBlockDimension(self):
179 """
179 """
180 Obtiene la cantidad de puntos a leer por cada bloque de datos
180 Obtiene la cantidad de puntos a leer por cada bloque de datos
181
181
182 Affected:
182 Affected:
183 self.blocksize
183 self.blocksize
184
184
185 Return:
185 Return:
186 None
186 None
187 """
187 """
188 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
188 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
189 self.blocksize = pts2read
189 self.blocksize = pts2read
190
190
191
191
192 def readBlock(self):
192 def readBlock(self):
193 """
193 """
194 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
194 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
195 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
195 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
196 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
196 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
197 es seteado a 0
197 es seteado a 0
198
198
199 Inputs:
199 Inputs:
200 None
200 None
201
201
202 Return:
202 Return:
203 None
203 None
204
204
205 Affected:
205 Affected:
206 self.profileIndex
206 self.profileIndex
207 self.datablock
207 self.datablock
208 self.flagIsNewFile
208 self.flagIsNewFile
209 self.flagIsNewBlock
209 self.flagIsNewBlock
210 self.nTotalBlocks
210 self.nTotalBlocks
211
211
212 Exceptions:
212 Exceptions:
213 Si un bloque leido no es un bloque valido
213 Si un bloque leido no es un bloque valido
214 """
214 """
215 current_pointer_location = self.fp.tell()
215 current_pointer_location = self.fp.tell()
216 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
216 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
217
217
218 try:
218 try:
219 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
219 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
220 except:
220 except:
221 #print "The read block (%3d) has not enough data" %self.nReadBlocks
221 #print "The read block (%3d) has not enough data" %self.nReadBlocks
222
222
223 if self.waitDataBlock(pointer_location=current_pointer_location):
223 if self.waitDataBlock(pointer_location=current_pointer_location):
224 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
224 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
225 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
225 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
226 # return 0
226 # return 0
227
227
228 #Dimensions : nChannels, nProfiles, nSamples
228 #Dimensions : nChannels, nProfiles, nSamples
229
229
230 junk = numpy.transpose(junk, (2,0,1))
230 junk = numpy.transpose(junk, (2,0,1))
231 self.datablock = junk['real'] + junk['imag']*1j
231 self.datablock = junk['real'] + junk['imag']*1j
232
232
233 self.profileIndex = 0
233 self.profileIndex = 0
234
234
235 self.flagIsNewFile = 0
235 self.flagIsNewFile = 0
236 self.flagIsNewBlock = 1
236 self.flagIsNewBlock = 1
237
237
238 self.nTotalBlocks += 1
238 self.nTotalBlocks += 1
239 self.nReadBlocks += 1
239 self.nReadBlocks += 1
240
240
241 return 1
241 return 1
242
242
243 def getFirstHeader(self):
243 def getFirstHeader(self):
244
244
245 self.getBasicHeader()
245 self.getBasicHeader()
246
246
247 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
247 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
248
248
249 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
249 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
250
250
251 if self.nTxs > 1:
251 if self.nTxs > 1:
252 self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
252 self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
253
253
254 #Time interval and code are propierties of dataOut. Its value depends of radarControllerHeaderObj.
254 #Time interval and code are propierties of dataOut. Its value depends of radarControllerHeaderObj.
255
255
256 # self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt
256 # self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt
257 #
257 #
258 # if self.radarControllerHeaderObj.code is not None:
258 # if self.radarControllerHeaderObj.code is not None:
259 #
259 #
260 # self.dataOut.nCode = self.radarControllerHeaderObj.nCode
260 # self.dataOut.nCode = self.radarControllerHeaderObj.nCode
261 #
261 #
262 # self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
262 # self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
263 #
263 #
264 # self.dataOut.code = self.radarControllerHeaderObj.code
264 # self.dataOut.code = self.radarControllerHeaderObj.code
265
265
266 self.dataOut.dtype = self.dtype
266 self.dataOut.dtype = self.dtype
267
267
268 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
268 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
269
269
270 if self.processingHeaderObj.nHeights % self.nTxs != 0:
270 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
271 raise ValueError, "nTxs (%d) should be a multiple of nHeights (%d)" %(self.nTxs, self.processingHeaderObj.nHeights)
272
273 xf = self.processingHeaderObj.firstHeight + int(self.processingHeaderObj.nHeights/self.nTxs)*self.processingHeaderObj.deltaHeight
274
275 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
276
271
277 self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
272 self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
278
273
279 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
274 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
280
275
281 self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
276 self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
282
277
283 self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data no esta sin flip
278 self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data no esta sin flip
284
279
285 self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
280 self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
286
281
282 def reshapeData(self):
283
284 if self.nTxs < 0:
285 return
286
287 if self.nTxs == 1:
288 return
289
290 if self.nTxs < 1 and self.processingHeaderObj.profilesPerBlock % (1./self.nTxs) != 0:
291 raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" %(1./self.nTxs, self.processingHeaderObj.profilesPerBlock)
292
293 if self.nTxs > 1 and self.processingHeaderObj.nHeights % self.nTxs != 0:
294 raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" %(self.nTxs, self.processingHeaderObj.nHeights)
295
296 self.datablock = self.datablock.reshape((self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock*self.nTxs, self.processingHeaderObj.nHeights/self.nTxs))
297
298 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
299 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights/self.nTxs) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
300 self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
301
302 return
303
287 def getData(self):
304 def getData(self):
288 """
305 """
289 getData obtiene una unidad de datos del buffer de lectura, un perfil, y la copia al objeto self.dataOut
306 getData obtiene una unidad de datos del buffer de lectura, un perfil, y la copia al objeto self.dataOut
290 del tipo "Voltage" con todos los parametros asociados a este (metadata). cuando no hay datos
307 del tipo "Voltage" con todos los parametros asociados a este (metadata). cuando no hay datos
291 en el buffer de lectura es necesario hacer una nueva lectura de los bloques de datos usando
308 en el buffer de lectura es necesario hacer una nueva lectura de los bloques de datos usando
292 "readNextBlock"
309 "readNextBlock"
293
310
294 Ademas incrementa el contador del buffer "self.profileIndex" en 1.
311 Ademas incrementa el contador del buffer "self.profileIndex" en 1.
295
312
296 Return:
313 Return:
297
314
298 Si el flag self.getByBlock ha sido seteado el bloque completo es copiado a self.dataOut y el self.profileIndex
315 Si el flag self.getByBlock ha sido seteado el bloque completo es copiado a self.dataOut y el self.profileIndex
299 es igual al total de perfiles leidos desde el archivo.
316 es igual al total de perfiles leidos desde el archivo.
300
317
301 Si self.getByBlock == False:
318 Si self.getByBlock == False:
302
319
303 self.dataOut.data = buffer[:, thisProfile, :]
320 self.dataOut.data = buffer[:, thisProfile, :]
304
321
305 shape = [nChannels, nHeis]
322 shape = [nChannels, nHeis]
306
323
307 Si self.getByBlock == True:
324 Si self.getByBlock == True:
308
325
309 self.dataOut.data = buffer[:, :, :]
326 self.dataOut.data = buffer[:, :, :]
310
327
311 shape = [nChannels, nProfiles, nHeis]
328 shape = [nChannels, nProfiles, nHeis]
312
329
313 Variables afectadas:
330 Variables afectadas:
314 self.dataOut
331 self.dataOut
315 self.profileIndex
332 self.profileIndex
316
333
317 Affected:
334 Affected:
318 self.dataOut
335 self.dataOut
319 self.profileIndex
336 self.profileIndex
320 self.flagDiscontinuousBlock
337 self.flagDiscontinuousBlock
321 self.flagIsNewBlock
338 self.flagIsNewBlock
322 """
339 """
323
340
324 if self.flagNoMoreFiles:
341 if self.flagNoMoreFiles:
325 self.dataOut.flagNoData = True
342 self.dataOut.flagNoData = True
326 print 'Process finished'
343 print 'Process finished'
327 return 0
344 return 0
328
345
329 self.flagDiscontinuousBlock = 0
346 self.flagDiscontinuousBlock = 0
330 self.flagIsNewBlock = 0
347 self.flagIsNewBlock = 0
331
348
332 if self.__hasNotDataInBuffer():
349 if self.__hasNotDataInBuffer():
333
350
334 if not( self.readNextBlock() ):
351 if not( self.readNextBlock() ):
335 return 0
352 return 0
336
353
337 self.getFirstHeader()
354 self.getFirstHeader()
355
356 self.reshapeData()
338
357
339 if self.datablock is None:
358 if self.datablock is None:
340 self.dataOut.flagNoData = True
359 self.dataOut.flagNoData = True
341 return 0
360 return 0
342
361
343 if not self.getByBlock:
362 if not self.getByBlock:
344
363
345 """
364 """
346 Return profile by profile
365 Return profile by profile
347
366
348 If nTxs > 1 then one profile is divided by nTxs and number of total
367 If nTxs > 1 then one profile is divided by nTxs and number of total
349 blocks is increased by nTxs (nProfiles *= nTxs)
368 blocks is increased by nTxs (nProfiles *= nTxs)
350 """
369 """
351 self.dataOut.flagDataAsBlock = False
370 self.dataOut.flagDataAsBlock = False
371 self.dataOut.data = self.datablock[:,self.profileIndex,:]
372 self.dataOut.profileIndex = self.profileIndex
352
373
353 if self.nTxs == 1:
374 self.profileIndex += 1
354 self.dataOut.data = self.datablock[:,self.profileIndex,:]
355 self.dataOut.profileIndex = self.profileIndex
356
357 self.profileIndex += 1
358
359 else:
360 iniHei_ForThisTx = (self.txIndex)*int(self.processingHeaderObj.nHeights/self.nTxs)
361 endHei_ForThisTx = (self.txIndex+1)*int(self.processingHeaderObj.nHeights/self.nTxs)
362
363 # print iniHei_ForThisTx, endHei_ForThisTx
364
365 self.dataOut.data = self.datablock[:, self.profileIndex, iniHei_ForThisTx:endHei_ForThisTx]
366 self.dataOut.profileIndex = self.profileIndex*self.nTxs + self.txIndex
367
368 self.txIndex += 1
369
370 if self.txIndex == self.nTxs:
371 self.txIndex = 0
372 self.profileIndex += 1
373
375
374 else:
376 else:
375 """
377 """
376 Return all block
378 Return all block
377 """
379 """
378 self.dataOut.flagDataAsBlock = True
380 self.dataOut.flagDataAsBlock = True
379 self.dataOut.data = self.datablock
381 self.dataOut.data = self.datablock
380 self.dataOut.profileIndex = self.processingHeaderObj.profilesPerBlock
382 self.dataOut.profileIndex = self.dataOut.nProfiles - 1
381
383
382 self.profileIndex = self.processingHeaderObj.profilesPerBlock
384 self.profileIndex = self.dataOut.nProfiles
383
385
384 self.dataOut.flagNoData = False
386 self.dataOut.flagNoData = False
385
387
386 self.getBasicHeader()
388 self.getBasicHeader()
387
389
388 self.dataOut.realtime = self.online
390 self.dataOut.realtime = self.online
389
391
390 return self.dataOut.data
392 return self.dataOut.data
391
393
392 class VoltageWriter(JRODataWriter, Operation):
394 class VoltageWriter(JRODataWriter, Operation):
393 """
395 """
394 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
396 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
395 de los datos siempre se realiza por bloques.
397 de los datos siempre se realiza por bloques.
396 """
398 """
397
399
398 ext = ".r"
400 ext = ".r"
399
401
400 optchar = "D"
402 optchar = "D"
401
403
402 shapeBuffer = None
404 shapeBuffer = None
403
405
404
406
405 def __init__(self):
407 def __init__(self):
406 """
408 """
407 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
409 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
408
410
409 Affected:
411 Affected:
410 self.dataOut
412 self.dataOut
411
413
412 Return: None
414 Return: None
413 """
415 """
414 Operation.__init__(self)
416 Operation.__init__(self)
415
417
416 self.nTotalBlocks = 0
418 self.nTotalBlocks = 0
417
419
418 self.profileIndex = 0
420 self.profileIndex = 0
419
421
420 self.isConfig = False
422 self.isConfig = False
421
423
422 self.fp = None
424 self.fp = None
423
425
424 self.flagIsNewFile = 1
426 self.flagIsNewFile = 1
425
427
426 self.blockIndex = 0
428 self.blockIndex = 0
427
429
428 self.flagIsNewBlock = 0
430 self.flagIsNewBlock = 0
429
431
430 self.setFile = None
432 self.setFile = None
431
433
432 self.dtype = None
434 self.dtype = None
433
435
434 self.path = None
436 self.path = None
435
437
436 self.filename = None
438 self.filename = None
437
439
438 self.basicHeaderObj = BasicHeader(LOCALTIME)
440 self.basicHeaderObj = BasicHeader(LOCALTIME)
439
441
440 self.systemHeaderObj = SystemHeader()
442 self.systemHeaderObj = SystemHeader()
441
443
442 self.radarControllerHeaderObj = RadarControllerHeader()
444 self.radarControllerHeaderObj = RadarControllerHeader()
443
445
444 self.processingHeaderObj = ProcessingHeader()
446 self.processingHeaderObj = ProcessingHeader()
445
447
446 def hasAllDataInBuffer(self):
448 def hasAllDataInBuffer(self):
447 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
449 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
448 return 1
450 return 1
449 return 0
451 return 0
450
452
451
453
452 def setBlockDimension(self):
454 def setBlockDimension(self):
453 """
455 """
454 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
456 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
455
457
456 Affected:
458 Affected:
457 self.shape_spc_Buffer
459 self.shape_spc_Buffer
458 self.shape_cspc_Buffer
460 self.shape_cspc_Buffer
459 self.shape_dc_Buffer
461 self.shape_dc_Buffer
460
462
461 Return: None
463 Return: None
462 """
464 """
463 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
465 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
464 self.processingHeaderObj.nHeights,
466 self.processingHeaderObj.nHeights,
465 self.systemHeaderObj.nChannels)
467 self.systemHeaderObj.nChannels)
466
468
467 self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
469 self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
468 self.processingHeaderObj.profilesPerBlock,
470 self.processingHeaderObj.profilesPerBlock,
469 self.processingHeaderObj.nHeights),
471 self.processingHeaderObj.nHeights),
470 dtype=numpy.dtype('complex64'))
472 dtype=numpy.dtype('complex64'))
471
473
472 def writeBlock(self):
474 def writeBlock(self):
473 """
475 """
474 Escribe el buffer en el file designado
476 Escribe el buffer en el file designado
475
477
476 Affected:
478 Affected:
477 self.profileIndex
479 self.profileIndex
478 self.flagIsNewFile
480 self.flagIsNewFile
479 self.flagIsNewBlock
481 self.flagIsNewBlock
480 self.nTotalBlocks
482 self.nTotalBlocks
481 self.blockIndex
483 self.blockIndex
482
484
483 Return: None
485 Return: None
484 """
486 """
485 data = numpy.zeros( self.shapeBuffer, self.dtype )
487 data = numpy.zeros( self.shapeBuffer, self.dtype )
486
488
487 junk = numpy.transpose(self.datablock, (1,2,0))
489 junk = numpy.transpose(self.datablock, (1,2,0))
488
490
489 data['real'] = junk.real
491 data['real'] = junk.real
490 data['imag'] = junk.imag
492 data['imag'] = junk.imag
491
493
492 data = data.reshape( (-1) )
494 data = data.reshape( (-1) )
493
495
494 data.tofile( self.fp )
496 data.tofile( self.fp )
495
497
496 self.datablock.fill(0)
498 self.datablock.fill(0)
497
499
498 self.profileIndex = 0
500 self.profileIndex = 0
499 self.flagIsNewFile = 0
501 self.flagIsNewFile = 0
500 self.flagIsNewBlock = 1
502 self.flagIsNewBlock = 1
501
503
502 self.blockIndex += 1
504 self.blockIndex += 1
503 self.nTotalBlocks += 1
505 self.nTotalBlocks += 1
504
506
505 # print "[Writing] Block = %04d" %self.blockIndex
507 # print "[Writing] Block = %04d" %self.blockIndex
506
508
507 def putData(self):
509 def putData(self):
508 """
510 """
509 Setea un bloque de datos y luego los escribe en un file
511 Setea un bloque de datos y luego los escribe en un file
510
512
511 Affected:
513 Affected:
512 self.flagIsNewBlock
514 self.flagIsNewBlock
513 self.profileIndex
515 self.profileIndex
514
516
515 Return:
517 Return:
516 0 : Si no hay data o no hay mas files que puedan escribirse
518 0 : Si no hay data o no hay mas files que puedan escribirse
517 1 : Si se escribio la data de un bloque en un file
519 1 : Si se escribio la data de un bloque en un file
518 """
520 """
519 if self.dataOut.flagNoData:
521 if self.dataOut.flagNoData:
520 return 0
522 return 0
521
523
522 self.flagIsNewBlock = 0
524 self.flagIsNewBlock = 0
523
525
524 if self.dataOut.flagDiscontinuousBlock:
526 if self.dataOut.flagDiscontinuousBlock:
525 self.datablock.fill(0)
527 self.datablock.fill(0)
526 self.profileIndex = 0
528 self.profileIndex = 0
527 self.setNextFile()
529 self.setNextFile()
528
530
529 if self.profileIndex == 0:
531 if self.profileIndex == 0:
530 self.setBasicHeader()
532 self.setBasicHeader()
531
533
532 self.datablock[:,self.profileIndex,:] = self.dataOut.data
534 self.datablock[:,self.profileIndex,:] = self.dataOut.data
533
535
534 self.profileIndex += 1
536 self.profileIndex += 1
535
537
536 if self.hasAllDataInBuffer():
538 if self.hasAllDataInBuffer():
537 #if self.flagIsNewFile:
539 #if self.flagIsNewFile:
538 self.writeNextBlock()
540 self.writeNextBlock()
539 # self.setFirstHeader()
541 # self.setFirstHeader()
540
542
541 return 1
543 return 1
542
544
543 def __getBlockSize(self):
545 def __getBlockSize(self):
544 '''
546 '''
545 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
547 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
546 '''
548 '''
547
549
548 dtype_width = self.getDtypeWidth()
550 dtype_width = self.getDtypeWidth()
549
551
550 blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.profilesPerBlock * dtype_width * 2)
552 blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.profilesPerBlock * dtype_width * 2)
551
553
552 return blocksize
554 return blocksize
553
555
554 def setFirstHeader(self):
556 def setFirstHeader(self):
555
557
556 """
558 """
557 Obtiene una copia del First Header
559 Obtiene una copia del First Header
558
560
559 Affected:
561 Affected:
560 self.systemHeaderObj
562 self.systemHeaderObj
561 self.radarControllerHeaderObj
563 self.radarControllerHeaderObj
562 self.dtype
564 self.dtype
563
565
564 Return:
566 Return:
565 None
567 None
566 """
568 """
567
569
568 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
570 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
569 self.systemHeaderObj.nChannels = self.dataOut.nChannels
571 self.systemHeaderObj.nChannels = self.dataOut.nChannels
570 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
572 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
571
573
572 self.processingHeaderObj.dtype = 0 # Voltage
574 self.processingHeaderObj.dtype = 0 # Voltage
573 self.processingHeaderObj.blockSize = self.__getBlockSize()
575 self.processingHeaderObj.blockSize = self.__getBlockSize()
574 self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
576 self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
575 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
577 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
576 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
578 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
577 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
579 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
578 self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
580 self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
579 self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
581 self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
580
582
581 if self.dataOut.code is not None:
583 if self.dataOut.code is not None:
582 self.processingHeaderObj.code = self.dataOut.code
584 self.processingHeaderObj.code = self.dataOut.code
583 self.processingHeaderObj.nCode = self.dataOut.nCode
585 self.processingHeaderObj.nCode = self.dataOut.nCode
584 self.processingHeaderObj.nBaud = self.dataOut.nBaud
586 self.processingHeaderObj.nBaud = self.dataOut.nBaud
585
587
586 if self.processingHeaderObj.nWindows != 0:
588 if self.processingHeaderObj.nWindows != 0:
587 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
589 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
588 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
590 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
589 self.processingHeaderObj.nHeights = self.dataOut.nHeights
591 self.processingHeaderObj.nHeights = self.dataOut.nHeights
590 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
592 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
591
593
592 self.processingHeaderObj.processFlags = self.getProcessFlags()
594 self.processingHeaderObj.processFlags = self.getProcessFlags()
593
595
594 self.setBasicHeader() No newline at end of file
596 self.setBasicHeader()
General Comments 0
You need to be logged in to leave comments. Login now