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