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