##// END OF EJS Templates
schain
RSS
VoltajeIO.py :...
Victor Sarmiento -
r66:20b047a1df95
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,388 +1,391
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author $Author$
4 @author $Author$
5 @version $Id$
5 @version $Id$
6 '''
6 '''
7
7
8 import os, sys
8 import os, sys
9 import numpy
9 import numpy
10 import glob
10 import glob
11 import fnmatch
11 import fnmatch
12 import time, datetime
12 import time, datetime
13
13
14 path = os.path.split(os.getcwd())[0]
14 path = os.path.split(os.getcwd())[0]
15 sys.path.append(path)
15 sys.path.append(path)
16
16
17 from Model.JROHeader import *
17 from Model.JROHeader import *
18 from Model.Voltage import Voltage
18 from Model.Voltage import Voltage
19
19
20 from IO.DataIO import JRODataReader
20 from IO.DataIO import JRODataReader
21 from IO.DataIO import JRODataWriter
21 from IO.DataIO import JRODataWriter
22
22
23
23
24 class VoltageReader(JRODataReader):
24 class VoltageReader(JRODataReader):
25 """
25 """
26 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
26 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
27 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
27 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
28 perfiles*alturas*canales) son almacenados en la variable "buffer".
28 perfiles*alturas*canales) son almacenados en la variable "buffer".
29
29
30 Voltajes - perfiles * alturas * canales
30 perfiles * alturas * canales
31
31
32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
33 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
33 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
34 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
34 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
35 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
35 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
36
36
37 Example:
37 Example:
38
38
39 dpath = "/home/myuser/data"
39 dpath = "/home/myuser/data"
40
40
41 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
41 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
42
42
43 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
43 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
44
44
45 readerObj = VoltageReader()
45 readerObj = VoltageReader()
46
46
47 readerObj.setup(dpath, startTime, endTime)
47 readerObj.setup(dpath, startTime, endTime)
48
48
49 while(True):
49 while(True):
50
50
51 #to get one profile
51 #to get one profile
52 profile = readerObj.getData()
52 profile = readerObj.getData()
53
53
54 #print the profile
54 #print the profile
55 print profile
55 print profile
56
56
57 #If you want to see all datablock
57 #If you want to see all datablock
58 print readerObj.datablock
58 print readerObj.datablock
59
59
60 if readerObj.flagNoMoreFiles:
60 if readerObj.flagNoMoreFiles:
61 break
61 break
62
62
63 """
63 """
64 m_DataObj = None
64 m_DataObj = None
65
65
66 idProfile = 0
66 idProfile = 0
67
67
68 datablock = None
68 datablock = None
69
69
70 ext = ".r"
71
72 pts2read = 0
70 pts2read = 0
73
71
74 utc = 0
72 utc = 0
75
73
74 ext = ".r"
75
76 optchar = "D"
77
76
78
77 def __init__(self, m_Voltage=None):
79 def __init__(self, m_Voltage=None):
78 """
80 """
79 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
81 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
80
82
81 Input:
83 Input:
82 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
84 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
83 almacenar un perfil de datos cada vez que se haga un requerimiento
85 almacenar un perfil de datos cada vez que se haga un requerimiento
84 (getData). El perfil sera obtenido a partir del buffer de datos,
86 (getData). El perfil sera obtenido a partir del buffer de datos,
85 si el buffer esta vacio se hara un nuevo proceso de lectura de un
87 si el buffer esta vacio se hara un nuevo proceso de lectura de un
86 bloque de datos.
88 bloque de datos.
87 Si este parametro no es pasado se creara uno internamente.
89 Si este parametro no es pasado se creara uno internamente.
88
90
89 Variables afectadas:
91 Variables afectadas:
90 self.m_DataObj
92 self.m_DataObj
91
93
92 Return:
94 Return:
93 None
95 None
94 """
96 """
95 if m_Voltage == None:
97 if m_Voltage == None:
96 m_Voltage = Voltage()
98 m_Voltage = Voltage()
97
99
98 if not(isinstance(m_Voltage, Voltage)):
100 if not(isinstance(m_Voltage, Voltage)):
99 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
101 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
100
102
101 self.m_DataObj = m_Voltage
103 self.m_DataObj = m_Voltage
102
104
103
105
104 def __hasNotDataInBuffer(self):
106 def __hasNotDataInBuffer(self):
105 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
107 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
106 return 1
108 return 1
107 return 0
109 return 0
108
110
109
111
110 def getBlockDimension(self):
112 def getBlockDimension(self):
111 """
113 """
112 Obtiene la cantidad de puntos a leer por cada bloque de datos
114 Obtiene la cantidad de puntos a leer por cada bloque de datos
113
115
114 Affected:
116 Affected:
115 self.pts2read
117 self.pts2read
116 self.blocksize
118 self.blocksize
117
119
118 Return:
120 Return:
119 None
121 None
120 """
122 """
121 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
123 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
122 self.blocksize = self.pts2read
124 self.blocksize = self.pts2read
123
125
124
126
125 def readBlock(self):
127 def readBlock(self):
126 """
128 """
127 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
129 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
128 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
130 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
129 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
131 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
130 es seteado a 0
132 es seteado a 0
131
133
132 Inputs:
134 Inputs:
133 None
135 None
134
136
135 Return:
137 Return:
136 None
138 None
137
139
138 Affected:
140 Affected:
139 self.datablockIndex
141 self.datablockIndex
140 self.datablock
142 self.datablock
141 self.flagIsNewFile
143 self.flagIsNewFile
142 self.idProfile
144 self.idProfile
143 self.flagIsNewBlock
145 self.flagIsNewBlock
144 self.nReadBlocks
146 self.nReadBlocks
145
147
146 Exceptions:
148 Exceptions:
147 Si un bloque leido no es un bloque valido
149 Si un bloque leido no es un bloque valido
148 """
150 """
149 blockOk_flag = False
151 blockOk_flag = False
150 fpointer = self.fp.tell()
152 fpointer = self.fp.tell()
151
153
152 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
154 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
153
155
154 if self.online:
156 if self.online:
155 if junk.size != self.blocksize:
157 if junk.size != self.blocksize:
156 for nTries in range( self.nTries ):
158 for nTries in range( self.nTries ):
157 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
159 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
158 time.sleep( self.delay )
160 time.sleep( self.delay )
159 self.fp.seek( fpointer )
161 self.fp.seek( fpointer )
160 fpointer = self.fp.tell()
162 fpointer = self.fp.tell()
163
161 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
164 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
165
162 if junk.size == self.blocksize:
166 if junk.size == self.blocksize:
163 blockOk_flag = True
167 blockOk_flag = True
164 break
168 break
165
169
166 if not( blockOk_flag ):
170 if not( blockOk_flag ):
167 return 0
171 return 0
168
172
169 try:
173 try:
170 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
174 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
171 except:
175 except:
172 print "Data file %s is invalid" % self.filename
176 print "Data file %s is invalid" % self.filename
173 return 0
177 return 0
174
178
175 #data = junk['real'] + junk['imag']*1j
176 self.datablock = junk['real'] + junk['imag']*1j
179 self.datablock = junk['real'] + junk['imag']*1j
177
180
178 self.datablockIndex = 0
181 self.datablockIndex = 0
179 self.flagIsNewFile = 0
182 self.flagIsNewFile = 0
180 self.idProfile = 0
183 self.idProfile = 0
181 self.flagIsNewBlock = 1
184 self.flagIsNewBlock = 1
182
185
183 self.nReadBlocks += 1
186 self.nReadBlocks += 1
184 self.nBlocks += 1
187 self.nBlocks += 1
185
188
186 return 1
189 return 1
187
190
188
191
189 def getData(self):
192 def getData(self):
190 """
193 """
191 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
194 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
192 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
195 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
193 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
196 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
194
197
195 Ademas incrementa el contador del buffer en 1.
198 Ademas incrementa el contador del buffer en 1.
196
199
197 Return:
200 Return:
198 data : retorna un perfil de voltages (alturas * canales) copiados desde el
201 data : retorna un perfil de voltages (alturas * canales) copiados desde el
199 buffer. Si no hay mas archivos a leer retorna None.
202 buffer. Si no hay mas archivos a leer retorna None.
200
203
201 Variables afectadas:
204 Variables afectadas:
202 self.m_DataObj
205 self.m_DataObj
203 self.datablockIndex
206 self.datablockIndex
204 self.idProfile
207 self.idProfile
205
208
206 Affected:
209 Affected:
207 self.m_DataObj
210 self.m_DataObj
208 self.datablockIndex
211 self.datablockIndex
209 self.flagResetProcessing
212 self.flagResetProcessing
210 self.flagIsNewBlock
213 self.flagIsNewBlock
211 self.idProfile
214 self.idProfile
212 """
215 """
213 if self.flagNoMoreFiles: return 0
216 if self.flagNoMoreFiles: return 0
214
217
215 self.flagResetProcessing = 0
218 self.flagResetProcessing = 0
216 self.flagIsNewBlock = 0
219 self.flagIsNewBlock = 0
217
220
218 if self.__hasNotDataInBuffer():
221 if self.__hasNotDataInBuffer():
219
222
220 if not( self.readNextBlock() ):
223 if not( self.readNextBlock() ):
221 self.setNextFile()
224 self.setNextFile()
222 return 0
225 return 0
223
226
224 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
227 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
225 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
228 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
226 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
229 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
227 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
230 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
228 self.m_DataObj.heights = self.heights
231 self.m_DataObj.heights = self.heights
229 self.m_DataObj.dataType = self.dataType
232 self.m_DataObj.dataType = self.dataType
230
233
231 if self.flagNoMoreFiles == 1:
234 if self.flagNoMoreFiles == 1:
232 print 'Process finished'
235 print 'Process finished'
233 return 0
236 return 0
234
237
235 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
238 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
236
239
237 if self.datablock == None:
240 if self.datablock == None:
238 self.m_DataObj.flagNoData = True
241 self.m_DataObj.flagNoData = True
239 return 0
242 return 0
240
243
241 time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
244 time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
242 self.utc = time
245 self.utc = time
243 #self.m_DataObj.m_BasicHeader.utc = time
246 #self.m_DataObj.m_BasicHeader.utc = time
244
247
245 self.m_DataObj.flagNoData = False
248 self.m_DataObj.flagNoData = False
246 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
249 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
247
250
248 self.m_DataObj.data = self.datablock[self.datablockIndex,:,:]
251 self.m_DataObj.data = self.datablock[self.datablockIndex,:,:]
249 self.m_DataObj.idProfile = self.idProfile
252 self.m_DataObj.idProfile = self.idProfile
250
253
251 self.datablockIndex += 1
254 self.datablockIndex += 1
252 self.idProfile += 1
255 self.idProfile += 1
253
256
254 #call setData - to Data Object
257 #call setData - to Data Object
255
258
256 return 1 #self.m_DataObj.data
259 return 1 #self.m_DataObj.data
257
260
258
261
259 class VoltageWriter( JRODataWriter ):
262 class VoltageWriter( JRODataWriter ):
260 """
263 """
261 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
264 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
262 de los datos siempre se realiza por bloques.
265 de los datos siempre se realiza por bloques.
263 """
266 """
264 __configHeaderFile = 'wrSetHeadet.txt'
267 __configHeaderFile = 'wrSetHeadet.txt'
265
268
266 m_DataObj = None
269 m_DataObj = None
267
270
268 datablock = None
269
270 datablockIndex = 0
271
272 ext = ".r"
271 ext = ".r"
273
272
274 optchar = "D"
273 optchar = "D"
275
274
275 datablock = None
276
277 datablockIndex = 0
278
276 shapeBuffer = None
279 shapeBuffer = None
277
280
278
281
279 def __init__(self, m_Voltage=None):
282 def __init__(self, m_Voltage=None):
280 """
283 """
281 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
284 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
282
285
283 Affected:
286 Affected:
284 self.m_DataObj
287 self.m_DataObj
285
288
286 Return: None
289 Return: None
287 """
290 """
288 if m_Voltage == None:
291 if m_Voltage == None:
289 m_Voltage = Voltage()
292 m_Voltage = Voltage()
290
293
291 if not( isinstance(m_Voltage, Voltage) ):
294 if not( isinstance(m_Voltage, Voltage) ):
292 raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
295 raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
293
296
294 self.m_DataObj = m_Voltage
297 self.m_DataObj = m_Voltage
295
298
296
299
297 def hasAllDataInBuffer(self):
300 def hasAllDataInBuffer(self):
298 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
301 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
299 return 1
302 return 1
300 return 0
303 return 0
301
304
302
305
303 def setBlockDimension(self):
306 def setBlockDimension(self):
304 """
307 """
305 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
308 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
306
309
307 Affected:
310 Affected:
308 self.shape_spc_Buffer
311 self.shape_spc_Buffer
309 self.shape_cspc_Buffer
312 self.shape_cspc_Buffer
310 self.shape_dc_Buffer
313 self.shape_dc_Buffer
311
314
312 Return: None
315 Return: None
313 """
316 """
314 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
317 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
315 self.m_ProcessingHeader.numHeights,
318 self.m_ProcessingHeader.numHeights,
316 self.m_SystemHeader.numChannels )
319 self.m_SystemHeader.numChannels )
317
320
318 self.datablock = numpy.zeros(self.shapeBuffer, numpy.dtype('complex'))
321 self.datablock = numpy.zeros(self.shapeBuffer, numpy.dtype('complex'))
319
322
320
323
321 def writeBlock(self):
324 def writeBlock(self):
322 """
325 """
323 Escribe el buffer en el file designado
326 Escribe el buffer en el file designado
324
327
325 Affected:
328 Affected:
326 self.datablockIndex
329 self.datablockIndex
327 self.flagIsNewFile
330 self.flagIsNewFile
328 self.flagIsNewBlock
331 self.flagIsNewBlock
329 self.nWriteBlocks
332 self.nWriteBlocks
330 self.blocksCounter
333 self.blocksCounter
331
334
332 Return: None
335 Return: None
333 """
336 """
334 data = numpy.zeros( self.shapeBuffer, self.dataType )
337 data = numpy.zeros( self.shapeBuffer, self.dataType )
335
338
336 data['real'] = self.datablock.real
339 data['real'] = self.datablock.real
337 data['imag'] = self.datablock.imag
340 data['imag'] = self.datablock.imag
338
341
339 data = data.reshape( (-1) )
342 data = data.reshape( (-1) )
340
343
341 data.tofile( self.fp )
344 data.tofile( self.fp )
342
345
343 self.datablock.fill(0)
346 self.datablock.fill(0)
344 self.datablockIndex = 0
347 self.datablockIndex = 0
345 self.flagIsNewFile = 0
348 self.flagIsNewFile = 0
346 self.flagIsNewBlock = 1
349 self.flagIsNewBlock = 1
347 self.nWriteBlocks += 1
350 self.nWriteBlocks += 1
348 self.blocksCounter += 1
351 self.blocksCounter += 1
349
352
350
353
351 def putData(self):
354 def putData(self):
352 """
355 """
353 Setea un bloque de datos y luego los escribe en un file
356 Setea un bloque de datos y luego los escribe en un file
354
357
355 Affected:
358 Affected:
356 self.flagIsNewBlock
359 self.flagIsNewBlock
357 self.datablockIndex
360 self.datablockIndex
358
361
359 Return:
362 Return:
360 0 : Si no hay data o no hay mas files que puedan escribirse
363 0 : Si no hay data o no hay mas files que puedan escribirse
361 1 : Si se escribio la data de un bloque en un file
364 1 : Si se escribio la data de un bloque en un file
362 """
365 """
363 self.flagIsNewBlock = 0
366 self.flagIsNewBlock = 0
364
367
365 if self.m_DataObj.flagNoData:
368 if self.m_DataObj.flagNoData:
366 return 0
369 return 0
367
370
368 if self.m_DataObj.flagResetProcessing:
371 if self.m_DataObj.flagResetProcessing:
369
372
370 self.datablock.fill(0)
373 self.datablock.fill(0)
371 self.datablockIndex = 0
374 self.datablockIndex = 0
372 self.setNextFile()
375 self.setNextFile()
373
376
374 self.datablock[self.datablockIndex,:,:] = self.m_DataObj.data
377 self.datablock[self.datablockIndex,:,:] = self.m_DataObj.data
375
378
376 self.datablockIndex += 1
379 self.datablockIndex += 1
377
380
378 if self.hasAllDataInBuffer():
381 if self.hasAllDataInBuffer():
379 #if self.flagIsNewFile:
382 #if self.flagIsNewFile:
380 self.getHeader()
383 self.getHeader()
381 self.writeNextBlock()
384 self.writeNextBlock()
382
385
383 if self.flagNoMoreFiles:
386 if self.flagNoMoreFiles:
384 #print 'Process finished'
387 #print 'Process finished'
385 return 0
388 return 0
386
389
387 return 1
390 return 1
388 No newline at end of file
391
General Comments 0
You need to be logged in to leave comments. Login now