##// END OF EJS Templates
schain
RSS
Bug fixed: La variable de tiempo "utc" no estaba siendo actualizada
Miguel Valdez -
r75:9e4ac0840d6d
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,398 +1,397
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 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 70 pts2read = 0
71 71
72 72 utc = 0
73 73
74 74 ext = ".r"
75 75
76 76 optchar = "D"
77 77
78 78
79 79 def __init__(self, m_Voltage=None):
80 80 """
81 81 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
82 82
83 83 Input:
84 84 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
85 85 almacenar un perfil de datos cada vez que se haga un requerimiento
86 86 (getData). El perfil sera obtenido a partir del buffer de datos,
87 87 si el buffer esta vacio se hara un nuevo proceso de lectura de un
88 88 bloque de datos.
89 89 Si este parametro no es pasado se creara uno internamente.
90 90
91 91 Variables afectadas:
92 92 self.m_DataObj
93 93
94 94 Return:
95 95 None
96 96 """
97 97 if m_Voltage == None:
98 98 m_Voltage = Voltage()
99 99
100 100 if not(isinstance(m_Voltage, Voltage)):
101 101 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
102 102
103 103 self.m_DataObj = m_Voltage
104 104
105 105
106 106 def __hasNotDataInBuffer(self):
107 107 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
108 108 return 1
109 109 return 0
110 110
111 111
112 112 def getBlockDimension(self):
113 113 """
114 114 Obtiene la cantidad de puntos a leer por cada bloque de datos
115 115
116 116 Affected:
117 117 self.pts2read
118 118 self.blocksize
119 119
120 120 Return:
121 121 None
122 122 """
123 123 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
124 124 self.blocksize = self.pts2read
125 125 self.m_DataObj.nProfiles = self.m_ProcessingHeader.profilesPerBlock
126 126
127 127
128 128 def readBlock(self):
129 129 """
130 130 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
131 131 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
132 132 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
133 133 es seteado a 0
134 134
135 135 Inputs:
136 136 None
137 137
138 138 Return:
139 139 None
140 140
141 141 Affected:
142 142 self.datablockIndex
143 143 self.datablock
144 144 self.flagIsNewFile
145 145 self.idProfile
146 146 self.flagIsNewBlock
147 147 self.nReadBlocks
148 148
149 149 Exceptions:
150 150 Si un bloque leido no es un bloque valido
151 151 """
152 152 blockOk_flag = False
153 153 fpointer = self.fp.tell()
154 154
155 155 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
156 156
157 157 if self.online:
158 158 if junk.size != self.blocksize:
159 159 for nTries in range( self.nTries ):
160 160 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
161 161 time.sleep( self.delay )
162 162 self.fp.seek( fpointer )
163 163 fpointer = self.fp.tell()
164 164
165 165 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
166 166
167 167 if junk.size == self.blocksize:
168 168 blockOk_flag = True
169 169 break
170 170
171 171 if not( blockOk_flag ):
172 172 return 0
173 173
174 174 try:
175 175 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
176 176 except:
177 177 print "Data file %s is invalid" % self.filename
178 178 return 0
179 179
180 180 junk = numpy.transpose(junk, (2,0,1))
181 181 self.datablock = junk['real'] + junk['imag']*1j
182 182
183 183 self.datablockIndex = 0
184 184 self.flagIsNewFile = 0
185 185 self.idProfile = 0
186 186 self.flagIsNewBlock = 1
187 187
188 188 self.nReadBlocks += 1
189 189 self.nBlocks += 1
190 190
191 191 return 1
192 192
193 193
194 194 def getData(self):
195 195 """
196 196 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
197 197 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
198 198 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
199 199
200 200 Ademas incrementa el contador del buffer en 1.
201 201
202 202 Return:
203 203 data : retorna un perfil de voltages (alturas * canales) copiados desde el
204 204 buffer. Si no hay mas archivos a leer retorna None.
205 205
206 206 Variables afectadas:
207 207 self.m_DataObj
208 208 self.datablockIndex
209 209 self.idProfile
210 210
211 211 Affected:
212 212 self.m_DataObj
213 213 self.datablockIndex
214 214 self.flagResetProcessing
215 215 self.flagIsNewBlock
216 216 self.idProfile
217 217 """
218 218 if self.flagNoMoreFiles: return 0
219 219
220 220 self.flagResetProcessing = 0
221 221 self.flagIsNewBlock = 0
222 222
223 223 if self.__hasNotDataInBuffer():
224 224
225 225 if not( self.readNextBlock() ):
226 226 self.setNextFile()
227 227 return 0
228 228
229 229 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
230 230 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
231 231 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
232 232 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
233 233 self.m_DataObj.heights = self.heights
234 234 self.m_DataObj.dataType = self.dataType
235 235
236 236 if self.flagNoMoreFiles == 1:
237 237 print 'Process finished'
238 238 return 0
239 239
240 240 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
241 241
242 242 if self.datablock == None:
243 243 self.m_DataObj.flagNoData = True
244 244 return 0
245 245
246 246 time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
247 self.utc = time
248 #self.m_DataObj.m_BasicHeader.utc = time
247 self.m_DataObj.m_BasicHeader.utc = time
249 248
250 249 self.m_DataObj.flagNoData = False
251 250 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
252 251
253 252 self.m_DataObj.data = self.datablock[:,self.datablockIndex,:]
254 253 self.m_DataObj.idProfile = self.idProfile
255 254
256 255 self.datablockIndex += 1
257 256 self.idProfile += 1
258 257
259 258 #call setData - to Data Object
260 259
261 260 return 1 #self.m_DataObj.data
262 261
263 262
264 263 class VoltageWriter( JRODataWriter ):
265 264 """
266 265 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
267 266 de los datos siempre se realiza por bloques.
268 267 """
269 268 __configHeaderFile = 'wrSetHeadet.txt'
270 269
271 270 m_DataObj = None
272 271
273 272 ext = ".r"
274 273
275 274 optchar = "D"
276 275
277 276 datablock = None
278 277
279 278 datablockIndex = 0
280 279
281 280 shapeBuffer = None
282 281
283 282
284 283 def __init__(self, m_Voltage=None):
285 284 """
286 285 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
287 286
288 287 Affected:
289 288 self.m_DataObj
290 289
291 290 Return: None
292 291 """
293 292 if m_Voltage == None:
294 293 m_Voltage = Voltage()
295 294
296 295 if not( isinstance(m_Voltage, Voltage) ):
297 296 raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
298 297
299 298 self.m_DataObj = m_Voltage
300 299
301 300
302 301 def hasAllDataInBuffer(self):
303 302 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
304 303 return 1
305 304 return 0
306 305
307 306
308 307 def setBlockDimension(self):
309 308 """
310 309 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
311 310
312 311 Affected:
313 312 self.shape_spc_Buffer
314 313 self.shape_cspc_Buffer
315 314 self.shape_dc_Buffer
316 315
317 316 Return: None
318 317 """
319 318 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
320 319 self.m_ProcessingHeader.numHeights,
321 320 self.m_SystemHeader.numChannels )
322 321
323 322 self.datablock = numpy.zeros(self.m_SystemHeader.numChannels,
324 323 self.m_ProcessingHeader.profilesPerBlock,
325 324 self.m_ProcessingHeader.numHeights,
326 325 numpy.dtype('complex'))
327 326
328 327
329 328 def writeBlock(self):
330 329 """
331 330 Escribe el buffer en el file designado
332 331
333 332 Affected:
334 333 self.datablockIndex
335 334 self.flagIsNewFile
336 335 self.flagIsNewBlock
337 336 self.nWriteBlocks
338 337 self.blocksCounter
339 338
340 339 Return: None
341 340 """
342 341 data = numpy.zeros( self.shapeBuffer, self.dataType )
343 342
344 343 junk = numpy.transpose(self.datablock, (1,2,0))
345 344
346 345 data['real'] = junk.real
347 346 data['imag'] = junk.imag
348 347
349 348 data = data.reshape( (-1) )
350 349
351 350 data.tofile( self.fp )
352 351
353 352 self.datablock.fill(0)
354 353 self.datablockIndex = 0
355 354 self.flagIsNewFile = 0
356 355 self.flagIsNewBlock = 1
357 356 self.nWriteBlocks += 1
358 357 self.blocksCounter += 1
359 358
360 359
361 360 def putData(self):
362 361 """
363 362 Setea un bloque de datos y luego los escribe en un file
364 363
365 364 Affected:
366 365 self.flagIsNewBlock
367 366 self.datablockIndex
368 367
369 368 Return:
370 369 0 : Si no hay data o no hay mas files que puedan escribirse
371 370 1 : Si se escribio la data de un bloque en un file
372 371 """
373 372 self.flagIsNewBlock = 0
374 373
375 374 if self.m_DataObj.flagNoData:
376 375 return 0
377 376
378 377 if self.m_DataObj.flagResetProcessing:
379 378
380 379 self.datablock.fill(0)
381 380 self.datablockIndex = 0
382 381 self.setNextFile()
383 382
384 383 self.datablock[:,self.datablockIndex,:] = self.m_DataObj.data
385 384
386 385 self.datablockIndex += 1
387 386
388 387 if self.hasAllDataInBuffer():
389 388 #if self.flagIsNewFile:
390 389 self.getHeader()
391 390 self.writeNextBlock()
392 391
393 392 if self.flagNoMoreFiles:
394 393 #print 'Process finished'
395 394 return 0
396 395
397 396 return 1
398 397 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now