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