##// END OF EJS Templates
schain-jc
RSS
Optimización del modulo de escritura de voltajes.
Miguel Valdez -
r23:7fedb37b4f03
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,929 +1,945
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 IO.HeaderIO import *
17 from IO.HeaderIO import *
18 from IO.DataIO import DataReader
18 from IO.DataIO import DataReader
19 from IO.DataIO import DataWriter
19 from IO.DataIO import DataWriter
20
20
21 from Model.Voltage import Voltage
21 from Model.Voltage import Voltage
22
22
23 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
23 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
24 """
24 """
25 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
25 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
26 o no dentro del rango de fecha especificado.
26 o no dentro del rango de fecha especificado.
27
27
28 Inputs:
28 Inputs:
29 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
29 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
30
30
31 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
31 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
32 segundos contados desde 01/01/1970.
32 segundos contados desde 01/01/1970.
33 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
33 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
34 segundos contados desde 01/01/1970.
34 segundos contados desde 01/01/1970.
35
35
36 Return:
36 Return:
37 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
37 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
38 fecha especificado, de lo contrario retorna False.
38 fecha especificado, de lo contrario retorna False.
39
39
40 Excepciones:
40 Excepciones:
41 Si el archivo no existe o no puede ser abierto
41 Si el archivo no existe o no puede ser abierto
42 Si la cabecera no puede ser leida.
42 Si la cabecera no puede ser leida.
43
43
44 """
44 """
45 m_BasicHeader = BasicHeader()
45 m_BasicHeader = BasicHeader()
46
46
47 try:
47 try:
48 fp = open(filename,'rb')
48 fp = open(filename,'rb')
49 except:
49 except:
50 raise IOError, "The file %s can't be opened" %(filename)
50 raise IOError, "The file %s can't be opened" %(filename)
51
51
52 if not(m_BasicHeader.read(fp)):
52 if not(m_BasicHeader.read(fp)):
53 raise IOError, "The file %s has not a valid header" %(filename)
53 raise IOError, "The file %s has not a valid header" %(filename)
54
54
55 fp.close()
55 fp.close()
56
56
57 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
57 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
58 return 0
58 return 0
59
59
60 return 1
60 return 1
61
61
62 class VoltageReader(DataReader):
62 class VoltageReader(DataReader):
63 """
63 """
64 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
64 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
65 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
65 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
66 perfiles*alturas*canales) son almacenados en la variable "buffer".
66 perfiles*alturas*canales) son almacenados en la variable "buffer".
67
67
68 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
68 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
69 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
69 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
70 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
70 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
71 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
71 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
72
72
73 Example:
73 Example:
74
74
75 dpath = "/home/myuser/data"
75 dpath = "/home/myuser/data"
76
76
77 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
77 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
78
78
79 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
79 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
80
80
81 readerObj = VoltageReader()
81 readerObj = VoltageReader()
82
82
83 readerObj.setup(dpath, startTime, endTime)
83 readerObj.setup(dpath, startTime, endTime)
84
84
85 while(True):
85 while(True):
86
86
87 readerObj.getData()
87 readerObj.getData()
88
88
89 print readerObj.m_Voltage.data
89 print readerObj.m_Voltage.data
90
90
91 if readerObj.noMoreFiles:
91 if readerObj.noMoreFiles:
92 break
92 break
93
93
94 """
94 """
95
95
96 #speed of light
96 #speed of light
97 __c = 3E8
97 __c = 3E8
98
98
99 def __init__(self, m_Voltage = None):
99 def __init__(self, m_Voltage = None):
100 """
100 """
101 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
101 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
102
102
103 Input:
103 Input:
104 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
104 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
105 almacenar un perfil de datos cada vez que se haga un requerimiento
105 almacenar un perfil de datos cada vez que se haga un requerimiento
106 (getData). El perfil sera obtenido a partir del buffer de datos,
106 (getData). El perfil sera obtenido a partir del buffer de datos,
107 si el buffer esta vacio se hara un nuevo proceso de lectura de un
107 si el buffer esta vacio se hara un nuevo proceso de lectura de un
108 bloque de datos.
108 bloque de datos.
109 Si este parametro no es pasado se creara uno internamente.
109 Si este parametro no es pasado se creara uno internamente.
110
110
111 Variables afectadas:
111 Variables afectadas:
112 self.m_Voltage
112 self.m_Voltage
113 self.m_BasicHeader
113 self.m_BasicHeader
114 self.m_SystemHeader
114 self.m_SystemHeader
115 self.m_RadarControllerHeader
115 self.m_RadarControllerHeader
116 self.m_ProcessingHeader
116 self.m_ProcessingHeader
117
117
118
118
119 Return:
119 Return:
120 Void
120 Void
121
121
122 """
122 """
123 if m_Voltage == None:
123 if m_Voltage == None:
124 m_Voltage = Voltage()
124 m_Voltage = Voltage()
125
125
126 if not(isinstance(m_Voltage, Voltage)):
126 if not(isinstance(m_Voltage, Voltage)):
127 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
127 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
128
128
129 self.m_Voltage = m_Voltage
129 self.m_Voltage = m_Voltage
130
130
131 self.m_BasicHeader = BasicHeader()
131 self.m_BasicHeader = BasicHeader()
132
132
133 self.m_SystemHeader = SystemHeader()
133 self.m_SystemHeader = SystemHeader()
134
134
135 self.m_RadarControllerHeader = RadarControllerHeader()
135 self.m_RadarControllerHeader = RadarControllerHeader()
136
136
137 self.m_ProcessingHeader = ProcessingHeader()
137 self.m_ProcessingHeader = ProcessingHeader()
138
138
139 self.__fp = None
139 self.__fp = None
140
140
141 self.__idFile = None
141 self.__idFile = None
142
142
143 self.__startDateTime = None
143 self.__startDateTime = None
144
144
145 self.__endDateTime = None
145 self.__endDateTime = None
146
146
147 self.__dataType = None
147 self.__dataType = None
148
148
149 self.__fileSizeByHeader = 0
149 self.__fileSizeByHeader = 0
150
150
151 self.__pathList = []
151 self.__pathList = []
152
152
153 self.filenameList = []
153 self.filenameList = []
154
154
155 self.__lastUTTime = 0
155 self.__lastUTTime = 0
156
156
157 self.__maxTimeStep = 30
157 self.__maxTimeStep = 30
158
158
159 self.__flagIsNewFile = 0
159 self.__flagIsNewFile = 0
160
160
161 self.__ippSeconds = 0
161 self.__ippSeconds = 0
162
162
163 self.flagResetProcessing = 0
163 self.flagResetProcessing = 0
164
164
165 self.flagIsNewBlock = 0
165 self.flagIsNewBlock = 0
166
166
167 self.noMoreFiles = 0
167 self.noMoreFiles = 0
168
168
169 self.nReadBlocks = 0
169 self.nReadBlocks = 0
170
170
171 self.online = 0
171 self.online = 0
172
172
173 self.filename = None
173 self.filename = None
174
174
175 self.fileSize = None
175 self.fileSize = None
176
176
177 self.firstHeaderSize = 0
177 self.firstHeaderSize = 0
178
178
179 self.basicHeaderSize = 24
179 self.basicHeaderSize = 24
180
180
181 self.idProfile = 0
181 self.idProfile = 0
182
182
183 self.__buffer = 0
183 self.__buffer = None
184
184
185 self.__buffer_id = 9999
185 self.__buffer_id = 9999
186
186
187 def __rdSystemHeader(self,fp=None):
187 def __rdSystemHeader(self,fp=None):
188 if fp == None:
188 if fp == None:
189 fp = self.__fp
189 fp = self.__fp
190
190
191 self.m_SystemHeader.read(fp)
191 self.m_SystemHeader.read(fp)
192
192
193 def __rdRadarControllerHeader(self,fp=None):
193 def __rdRadarControllerHeader(self,fp=None):
194 if fp == None:
194 if fp == None:
195 fp = self.__fp
195 fp = self.__fp
196
196
197 self.m_RadarControllerHeader.read(fp)
197 self.m_RadarControllerHeader.read(fp)
198
198
199 def __rdProcessingHeader(self,fp=None):
199 def __rdProcessingHeader(self,fp=None):
200 if fp == None:
200 if fp == None:
201 fp = self.__fp
201 fp = self.__fp
202
202
203 self.m_ProcessingHeader.read(fp)
203 self.m_ProcessingHeader.read(fp)
204
204
205 def __rdBasicHeader(self, fp=None):
205 def __rdBasicHeader(self, fp=None):
206
206
207 if fp == None:
207 if fp == None:
208 fp = self.__fp
208 fp = self.__fp
209
209
210 self.m_BasicHeader.read(fp)
210 self.m_BasicHeader.read(fp)
211
211
212 def __readFirstHeader(self):
212 def __readFirstHeader(self):
213
213
214 self.__rdBasicHeader()
214 self.__rdBasicHeader()
215 self.__rdSystemHeader()
215 self.__rdSystemHeader()
216 self.__rdRadarControllerHeader()
216 self.__rdRadarControllerHeader()
217 self.__rdProcessingHeader()
217 self.__rdProcessingHeader()
218 self.firstHeaderSize = self.m_BasicHeader.size
218 self.firstHeaderSize = self.m_BasicHeader.size
219
219
220 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
220 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
221 if data_type == 0:
221 if data_type == 0:
222 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
222 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
223
223
224 elif data_type == 1:
224 elif data_type == 1:
225 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
225 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
226
226
227 elif data_type == 2:
227 elif data_type == 2:
228 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
228 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
229
229
230 elif data_type == 3:
230 elif data_type == 3:
231 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
231 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
232
232
233 elif data_type == 4:
233 elif data_type == 4:
234 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
234 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
235
235
236 elif data_type == 5:
236 elif data_type == 5:
237 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
237 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
238
238
239 else:
239 else:
240 raise ValueError, 'Data type was not defined'
240 raise ValueError, 'Data type was not defined'
241
241
242 xi = self.m_ProcessingHeader.firstHeight
242 xi = self.m_ProcessingHeader.firstHeight
243 step = self.m_ProcessingHeader.deltaHeight
243 step = self.m_ProcessingHeader.deltaHeight
244 xf = xi + self.m_ProcessingHeader.numHeights*step
244 xf = xi + self.m_ProcessingHeader.numHeights*step
245
245
246 self.__heights = numpy.arange(xi, xf, step)
246 self.__heights = numpy.arange(xi, xf, step)
247 self.__dataType = tmp
247 self.__dataType = tmp
248 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
248 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
249 self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/self.__c
249 self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/self.__c
250
250
251 def __setNextFileOnline(self):
251 def __setNextFileOnline(self):
252 return 0
252 return 0
253
253
254 def __setNextFileOffline(self):
254 def __setNextFileOffline(self):
255
255
256 idFile = self.__idFile
256 idFile = self.__idFile
257 while(True):
257 while(True):
258
258
259 idFile += 1
259 idFile += 1
260
260
261 if not(idFile < len(self.filenameList)):
261 if not(idFile < len(self.filenameList)):
262 self.noMoreFiles = 1
262 self.noMoreFiles = 1
263 return 0
263 return 0
264
264
265 filename = self.filenameList[idFile]
265 filename = self.filenameList[idFile]
266 fileSize = os.path.getsize(filename)
266 fileSize = os.path.getsize(filename)
267
267
268 try:
268 try:
269 fp = open(filename,'rb')
269 fp = open(filename,'rb')
270 except:
270 except:
271 raise IOError, "The file %s can't be opened" %filename
271 raise IOError, "The file %s can't be opened" %filename
272
272
273 currentSize = fileSize - fp.tell()
273 currentSize = fileSize - fp.tell()
274 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
274 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
275
275
276 if (currentSize < neededSize):
276 if (currentSize < neededSize):
277 print "Skipping the file %s due to it hasn't enough data" %filename
277 print "Skipping the file %s due to it hasn't enough data" %filename
278 continue
278 continue
279
279
280 break
280 break
281
281
282 self.__flagIsNewFile = 1
282 self.__flagIsNewFile = 1
283 self.__idFile = idFile
283 self.__idFile = idFile
284 self.filename = filename
284 self.filename = filename
285 self.fileSize = fileSize
285 self.fileSize = fileSize
286 self.__fp = fp
286 self.__fp = fp
287
287
288 print 'Setting the file: %s'%self.filename
288 print 'Setting the file: %s'%self.filename
289
289
290 return 1
290 return 1
291
291
292 def __setNextFile(self):
292 def __setNextFile(self):
293
293
294 if self.online:
294 if self.online:
295 newFile = self.__setNextFileOnline()
295 newFile = self.__setNextFileOnline()
296 else:
296 else:
297 newFile = self.__setNextFileOffline()
297 newFile = self.__setNextFileOffline()
298
298
299 if not(newFile):
299 if not(newFile):
300 return 0
300 return 0
301
301
302 self.__readFirstHeader()
302 self.__readFirstHeader()
303
303
304 return 1
304 return 1
305
305
306 def __setNewBlock(self):
306 def __setNewBlock(self):
307
307
308 if self.__fp == None:
308 if self.__fp == None:
309 return 0
309 return 0
310
310
311 if self.__flagIsNewFile:
311 if self.__flagIsNewFile:
312 return 1
312 return 1
313
313
314 currentSize = self.fileSize - self.__fp.tell()
314 currentSize = self.fileSize - self.__fp.tell()
315 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
315 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
316
316
317 #If there is enough data setting new data block
317 #If there is enough data setting new data block
318 if (currentSize >= neededSize):
318 if (currentSize >= neededSize):
319 self.__rdBasicHeader()
319 self.__rdBasicHeader()
320 return 1
320 return 1
321
321
322 #Setting new file
322 #Setting new file
323 if not(self.__setNextFile()):
323 if not(self.__setNextFile()):
324 return 0
324 return 0
325
325
326 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
326 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
327
327
328 self.flagResetProcessing = 0
328 self.flagResetProcessing = 0
329
329
330 if deltaTime > self.__maxTimeStep:
330 if deltaTime > self.__maxTimeStep:
331 self.flagResetProcessing = 1
331 self.flagResetProcessing = 1
332 self.nReadBlocks = 0
332 self.nReadBlocks = 0
333
333
334 return 1
334 return 1
335
335
336 def __readBlock(self):
336 def __readBlock(self):
337 """
337 """
338 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
338 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
339 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
339 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
340 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
340 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
341 es seteado a 0
341 es seteado a 0
342
342
343
343
344 Inputs:
344 Inputs:
345 None
345 None
346
346
347 Return:
347 Return:
348 None
348 None
349
349
350 Variables afectadas:
350 Variables afectadas:
351
351
352 self.__buffer_id
352 self.__buffer_id
353
353
354 self.__buffer
354 self.__buffer
355
355
356 self.__flagIsNewFile
356 self.__flagIsNewFile
357
357
358 self.idProfile
358 self.idProfile
359
359
360 self.flagIsNewBlock
360 self.flagIsNewBlock
361
361
362 self.nReadBlocks
362 self.nReadBlocks
363
363
364 """
364 """
365
365
366 pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
366 pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
367
367
368 junk = numpy.fromfile(self.__fp, self.__dataType, pts2read)
368 junk = numpy.fromfile(self.__fp, self.__dataType, pts2read)
369
369
370 junk = junk.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels))
370 junk = junk.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels))
371
371
372 data = junk['real'] + junk['imag']*1j
372 data = junk['real'] + junk['imag']*1j
373
373
374 self.__buffer_id = 0
374 self.__buffer_id = 0
375
375
376 self.__buffer = data
376 self.__buffer = data
377
377
378 self.__flagIsNewFile = 0
378 self.__flagIsNewFile = 0
379
379
380 self.idProfile = 0
380 self.idProfile = 0
381
381
382 self.flagIsNewBlock = 1
382 self.flagIsNewBlock = 1
383
383
384 self.nReadBlocks += 1
384 self.nReadBlocks += 1
385
385
386 def __hasNotDataInBuffer(self):
386 def __hasNotDataInBuffer(self):
387 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
387 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
388 return 1
388 return 1
389
389
390 return 0
390 return 0
391
391
392 def __searchFiles(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
392 def __searchFiles(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
393 """
393 """
394 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
394 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
395 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
395 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
396 correcta la estructura de directorios debe ser la siguiente:
396 correcta la estructura de directorios debe ser la siguiente:
397
397
398 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
398 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
399
399
400 [yyyy]: anio
400 [yyyy]: anio
401 [ddd] : dia del anio
401 [ddd] : dia del anio
402 [sss] : set del archivo
402 [sss] : set del archivo
403
403
404 Inputs:
404 Inputs:
405 path : Directorio de datos donde se realizara la busqueda. Todos los
405 path : Directorio de datos donde se realizara la busqueda. Todos los
406 ficheros que concidan con el criterio de busqueda seran
406 ficheros que concidan con el criterio de busqueda seran
407 almacenados en una lista y luego retornados.
407 almacenados en una lista y luego retornados.
408 startDateTime : Fecha inicial. Rechaza todos los archivos donde
408 startDateTime : Fecha inicial. Rechaza todos los archivos donde
409 file end time < startDateTime (obejto datetime.datetime)
409 file end time < startDateTime (obejto datetime.datetime)
410
410
411 endDateTime : Fecha final. Rechaza todos los archivos donde
411 endDateTime : Fecha final. Rechaza todos los archivos donde
412 file start time > endDateTime (obejto datetime.datetime)
412 file start time > endDateTime (obejto datetime.datetime)
413
413
414 set : Set del primer archivo a leer. Por defecto None
414 set : Set del primer archivo a leer. Por defecto None
415
415
416 expLabel : Nombre del subdirectorio de datos. Por defecto ""
416 expLabel : Nombre del subdirectorio de datos. Por defecto ""
417
417
418 ext : Extension de los archivos a leer. Por defecto .r
418 ext : Extension de los archivos a leer. Por defecto .r
419
419
420 Return:
420 Return:
421
421
422 (pathList, filenameList)
422 (pathList, filenameList)
423
423
424 pathList : Lista de directorios donde se encontraron archivos dentro
424 pathList : Lista de directorios donde se encontraron archivos dentro
425 de los parametros especificados
425 de los parametros especificados
426 filenameList : Lista de archivos (ruta completa) que coincidieron con los
426 filenameList : Lista de archivos (ruta completa) que coincidieron con los
427 parametros especificados.
427 parametros especificados.
428
428
429 Variables afectadas:
429 Variables afectadas:
430
430
431 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
431 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
432 como fuente para leer los bloque de datos, si se termina
432 como fuente para leer los bloque de datos, si se termina
433 de leer todos los bloques de datos de un determinado
433 de leer todos los bloques de datos de un determinado
434 archivo se pasa al siguiente archivo de la lista.
434 archivo se pasa al siguiente archivo de la lista.
435
435
436 Excepciones:
436 Excepciones:
437
437
438 """
438 """
439
439
440 print "Searching files ..."
440 print "Searching files ..."
441
441
442 dirList = []
442 dirList = []
443 for thisPath in os.listdir(path):
443 for thisPath in os.listdir(path):
444 if os.path.isdir(os.path.join(path,thisPath)):
444 if os.path.isdir(os.path.join(path,thisPath)):
445 dirList.append(thisPath)
445 dirList.append(thisPath)
446
446
447 pathList = []
447 pathList = []
448
448
449 thisDateTime = startDateTime
449 thisDateTime = startDateTime
450
450
451 while(thisDateTime <= endDateTime):
451 while(thisDateTime <= endDateTime):
452 year = thisDateTime.timetuple().tm_year
452 year = thisDateTime.timetuple().tm_year
453 doy = thisDateTime.timetuple().tm_yday
453 doy = thisDateTime.timetuple().tm_yday
454
454
455 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
455 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
456 if len(match) == 0:
456 if len(match) == 0:
457 thisDateTime += datetime.timedelta(1)
457 thisDateTime += datetime.timedelta(1)
458 continue
458 continue
459
459
460 pathList.append(os.path.join(path,match[0],expLabel))
460 pathList.append(os.path.join(path,match[0],expLabel))
461 thisDateTime += datetime.timedelta(1)
461 thisDateTime += datetime.timedelta(1)
462
462
463 startUtSeconds = time.mktime(startDateTime.timetuple())
463 startUtSeconds = time.mktime(startDateTime.timetuple())
464 endUtSeconds = time.mktime(endDateTime.timetuple())
464 endUtSeconds = time.mktime(endDateTime.timetuple())
465
465
466 filenameList = []
466 filenameList = []
467 for thisPath in pathList:
467 for thisPath in pathList:
468 fileList = glob.glob1(thisPath, "*%s" %ext)
468 fileList = glob.glob1(thisPath, "*%s" %ext)
469 fileList.sort()
469 fileList.sort()
470 for file in fileList:
470 for file in fileList:
471 filename = os.path.join(thisPath,file)
471 filename = os.path.join(thisPath,file)
472 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
472 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
473 filenameList.append(filename)
473 filenameList.append(filename)
474
474
475 self.filenameList = filenameList
475 self.filenameList = filenameList
476
476
477 return pathList, filenameList
477 return pathList, filenameList
478
478
479 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0):
479 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0):
480 """
480 """
481 setup configura los parametros de lectura de la clase VoltageReader.
481 setup configura los parametros de lectura de la clase VoltageReader.
482
482
483 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
483 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
484 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
484 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
485 self.filenameList.
485 self.filenameList.
486
486
487 Input:
487 Input:
488 path : Directorios donde se ubican los datos a leer. Dentro de este
488 path : Directorios donde se ubican los datos a leer. Dentro de este
489 directorio deberia de estar subdirectorios de la forma:
489 directorio deberia de estar subdirectorios de la forma:
490
490
491 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
491 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
492
492
493 startDateTime : Fecha inicial. Rechaza todos los archivos donde
493 startDateTime : Fecha inicial. Rechaza todos los archivos donde
494 file end time < startDatetime (obejto datetime.datetime)
494 file end time < startDatetime (obejto datetime.datetime)
495
495
496 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
496 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
497 file end time < startDatetime (obejto datetime.datetime)
497 file end time < startDatetime (obejto datetime.datetime)
498
498
499 set : Set del primer archivo a leer. Por defecto None
499 set : Set del primer archivo a leer. Por defecto None
500
500
501 expLabel : Nombre del subdirectorio de datos. Por defecto ""
501 expLabel : Nombre del subdirectorio de datos. Por defecto ""
502
502
503 ext : Extension de los archivos a leer. Por defecto .r
503 ext : Extension de los archivos a leer. Por defecto .r
504
504
505 online :
505 online :
506
506
507 Return:
507 Return:
508
508
509 Affected:
509 Affected:
510
510
511 Excepciones:
511 Excepciones:
512
512
513 Example:
513 Example:
514
514
515 """
515 """
516
516
517 if online == 0:
517 if online == 0:
518 pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext)
518 pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext)
519
519
520 self.__idFile = -1
520 self.__idFile = -1
521
521
522 if not(self.__setNextFile()):
522 if not(self.__setNextFile()):
523 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
523 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
524 return 0
524 return 0
525
525
526 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
526 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
527 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
527 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
528
528
529 self.startYear = startDateTime.timetuple().tm_year
529 self.startYear = startDateTime.timetuple().tm_year
530 self.endYear = endDateTime.timetuple().tm_year
530 self.endYear = endDateTime.timetuple().tm_year
531
531
532 self.startDoy = startDateTime.timetuple().tm_yday
532 self.startDoy = startDateTime.timetuple().tm_yday
533 self.endDoy = endDateTime.timetuple().tm_yday
533 self.endDoy = endDateTime.timetuple().tm_yday
534
534
535 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
535 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
536 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
536 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
537 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
537 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
538 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
538 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
539 self.m_Voltage.dataType = self.__dataType
539 self.m_Voltage.dataType = self.__dataType
540
540
541 self.__pathList = pathList
541 self.__pathList = pathList
542 self.filenameList = filenameList
542 self.filenameList = filenameList
543 self.online = online
543 self.online = online
544
544
545 return 1
546
545 def readNextBlock(self):
547 def readNextBlock(self):
546 """
548 """
547 readNextBlock establece un nuevo bloque de datos a leer y los lee, si es que no existiese
549 readNextBlock establece un nuevo bloque de datos a leer y los lee, si es que no existiese
548 mas bloques disponibles en el archivo actual salta al siguiente.
550 mas bloques disponibles en el archivo actual salta al siguiente.
549
551
550 """
552 """
551
553
552 if not(self.__setNewBlock()):
554 if not(self.__setNewBlock()):
553 return 0
555 return 0
554
556
555 self.__readBlock()
557 self.__readBlock()
556
558
557 self.__lastUTTime = self.m_BasicHeader.utc
559 self.__lastUTTime = self.m_BasicHeader.utc
558
560
559 return 1
561 return 1
560
562
561 def getData(self):
563 def getData(self):
562 """
564 """
563 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
565 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
564 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
566 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
565 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
567 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
566
568
567 Ademas incrementa el contador del buffer en 1.
569 Ademas incrementa el contador del buffer en 1.
568
570
569 Inputs:
571 Inputs:
570 None
572 None
571
573
572 Return:
574 Return:
573 data : retorna un perfil de voltages (alturas * canales) copiados desde el
575 data : retorna un perfil de voltages (alturas * canales) copiados desde el
574 buffer. Si no hay mas archivos a leer retorna None.
576 buffer. Si no hay mas archivos a leer retorna None.
575
577
576 Variables afectadas:
578 Variables afectadas:
577 self.m_Voltage
579 self.m_Voltage
578 self.__buffer_id
580 self.__buffer_id
579 self.idProfile
581 self.idProfile
580
582
581 Excepciones:
583 Excepciones:
582
584
583 """
585 """
584 self.flagResetProcessing = 0
586 self.flagResetProcessing = 0
585 self.flagIsNewBlock = 0
587 self.flagIsNewBlock = 0
586
588
587 if self.__hasNotDataInBuffer():
589 if self.__hasNotDataInBuffer():
588 self.readNextBlock()
590 self.readNextBlock()
589
591
592 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
593 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
594 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
595 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
596
597 self.m_Voltage.heights = self.__heights
598 self.m_Voltage.dataType = self.__dataType
599
590 if self.noMoreFiles == 1:
600 if self.noMoreFiles == 1:
591 print 'Process finished'
601 print 'Process finished'
592 return None
602 return None
593
603
594 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
604 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
595 data = self.__buffer[self.__buffer_id,:,:]
596
605
597 time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
606 time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
598
607 self.m_Voltage.m_BasicHeader.utc = time
599 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
608 self.m_Voltage.data = self.__buffer[self.__buffer_id,:,:]
600 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
601 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
602 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
603 self.m_Voltage.m_BasicHeader.utc = time
604 self.m_Voltage.data = data
605 self.m_Voltage.flagNoData = False
609 self.m_Voltage.flagNoData = False
606 self.m_Voltage.flagResetProcessing = self.flagResetProcessing
610 self.m_Voltage.flagResetProcessing = self.flagResetProcessing
607 self.m_Voltage.heights = self.__heights
611
608 self.m_Voltage.idProfile = self.idProfile
612 self.m_Voltage.idProfile = self.idProfile
609 self.m_Voltage.dataType = self.__dataType
613
610
614
611 self.__buffer_id += 1
615 self.__buffer_id += 1
612 self.idProfile += 1
616 self.idProfile += 1
613
617
614 #call setData - to Data Object
618 #call setData - to Data Object
615
619
616 return data
620 return 1
617
621
618 class VoltageWriter(DataWriter):
622 class VoltageWriter(DataWriter):
619 __configHeaderFile = 'wrSetHeadet.txt'
623 __configHeaderFile = 'wrSetHeadet.txt'
620
624
621 def __init__(self, m_Voltage = None):
625 def __init__(self, m_Voltage = None):
622
626
623 if m_Voltage == None:
627 if m_Voltage == None:
624 m_Voltage = Voltage()
628 m_Voltage = Voltage()
625
629
626 self.m_Voltage = m_Voltage
630 self.m_Voltage = m_Voltage
627
631
628 self.__path = None
632 self.__path = None
629
633
630 self.__fp = None
634 self.__fp = None
631
635
632 self.__format = None
636 self.__format = None
633
637
634 self.__blocksCounter = 0
638 self.__blocksCounter = 0
635
639
636 self.__setFile = None
640 self.__setFile = None
637
641
638 self.__flagIsNewFile = 1
642 self.__flagIsNewFile = 1
639
643
640 self.__buffer = 0
644 self.__buffer = None
641
645
642 self.__buffer_id = 0
646 self.__buffer_id = 0
643
647
644 self.__dataType = None
648 self.__dataType = None
645
649
646 self.__ext = None
650 self.__ext = None
647
651
652 self.__shapeBuffer = None
653
648 self.nWriteBlocks = 0
654 self.nWriteBlocks = 0
649
655
650 self.flagIsNewBlock = 0
656 self.flagIsNewBlock = 0
651
657
652 self.noMoreFiles = 0
658 self.noMoreFiles = 0
653
659
654 self.filename = None
660 self.filename = None
655
661
656 self.m_BasicHeader= BasicHeader()
662 self.m_BasicHeader= BasicHeader()
657
663
658 self.m_SystemHeader = SystemHeader()
664 self.m_SystemHeader = SystemHeader()
659
665
660 self.m_RadarControllerHeader = RadarControllerHeader()
666 self.m_RadarControllerHeader = RadarControllerHeader()
661
667
662 self.m_ProcessingHeader = ProcessingHeader()
668 self.m_ProcessingHeader = ProcessingHeader()
663
669
664
670
665 def __writeBasicHeader(self, fp=None):
671 def __writeBasicHeader(self, fp=None):
666 if fp == None:
672 if fp == None:
667 fp = self.__fp
673 fp = self.__fp
668
674
669 self.m_BasicHeader.write(fp)
675 self.m_BasicHeader.write(fp)
670
676
671 def __wrSystemHeader(self,fp=None):
677 def __wrSystemHeader(self,fp=None):
672 if fp == None:
678 if fp == None:
673 fp = self.__fp
679 fp = self.__fp
674
680
675 self.m_SystemHeader.write(fp)
681 self.m_SystemHeader.write(fp)
676
682
677 def __wrRadarControllerHeader(self,fp=None):
683 def __wrRadarControllerHeader(self,fp=None):
678 if fp == None:
684 if fp == None:
679 fp = self.__fp
685 fp = self.__fp
680
686
681 self.m_RadarControllerHeader.write(fp)
687 self.m_RadarControllerHeader.write(fp)
682
688
683 def __wrProcessingHeader(self,fp=None):
689 def __wrProcessingHeader(self,fp=None):
684 if fp == None:
690 if fp == None:
685 fp = self.__fp
691 fp = self.__fp
686
692
687 self.m_ProcessingHeader.write(fp)
693 self.m_ProcessingHeader.write(fp)
688
694
689 def __writeFirstHeader(self):
695 def __writeFirstHeader(self):
690 self.__writeBasicHeader()
696 self.__writeBasicHeader()
691 self.__wrSystemHeader()
697 self.__wrSystemHeader()
692 self.__wrRadarControllerHeader()
698 self.__wrRadarControllerHeader()
693 self.__wrProcessingHeader()
699 self.__wrProcessingHeader()
694 self.__dataType = self.m_Voltage.dataType
700 self.__dataType = self.m_Voltage.dataType
695
701
696
702
697 def __setNextFile(self):
703 def __setNextFile(self):
698
704
699 setFile = self.__setFile
705 setFile = self.__setFile
700 ext = self.__ext
706 ext = self.__ext
701 path = self.__path
707 path = self.__path
702
708
703 setFile += 1
709 setFile += 1
704
710
705 if self.__fp != None:
711 if self.__fp != None:
706 self.__fp.close()
712 self.__fp.close()
707
713
708 timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
714 timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
709 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext)
715 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext)
710 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
716 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
711 tmp = os.path.join(path,subfolder)
717 tmp = os.path.join(path,subfolder)
712 if not(os.path.exists(tmp)):
718 if not(os.path.exists(tmp)):
713 os.mkdir(tmp)
719 os.mkdir(tmp)
714
720
715 filename = os.path.join(path,subfolder,file)
721 filename = os.path.join(path,subfolder,file)
716 fp = open(filename,'wb')
722 fp = open(filename,'wb')
717
723
718 self.__blocksCounter = 0
724 self.__blocksCounter = 0
719
725
720 #guardando atributos
726 #guardando atributos
721 self.filename = filename
727 self.filename = filename
722 self.__subfolder = subfolder
728 self.__subfolder = subfolder
723 self.__fp = fp
729 self.__fp = fp
724 self.__setFile = setFile
730 self.__setFile = setFile
725 self.__flagIsNewFile = 1
731 self.__flagIsNewFile = 1
726
732
727 print 'Writing the file: %s'%self.filename
733 print 'Writing the file: %s'%self.filename
728
734
729 self.__writeFirstHeader()
735 self.__writeFirstHeader()
730
736
731 return 1
737 return 1
732
738
733 def __setNewBlock(self):
739 def __setNewBlock(self):
740
734 if self.__fp == None:
741 if self.__fp == None:
735 return 0
742 self.__setNextFile()
736
743
737 if self.__flagIsNewFile:
744 if self.__flagIsNewFile:
738 return 1
745 return 1
739
746
740 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
747 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
741 self.__writeBasicHeader()
748 self.__writeBasicHeader()
742 return 1
749 return 1
743
750
744 if not(self.__setNextFile()):
751 if not(self.__setNextFile()):
745 return 0
752 return 0
746
753
747 return 1
754 return 1
748
755
749 def __writeBlock(self):
756 def __writeBlock(self):
750
751 self.__buffer.tofile(self.__fp)
752
757
753 self.__buffer = numpy.array([],self.__dataType)
758 data = numpy.zeros(self.__shapeBuffer, self.__dataType)
759
760 data['real'] = self.__buffer.real
761 data['imag'] = self.__buffer.imag
762
763 data = data.reshape((-1))
764
765 data.tofile(self.__fp)
766
767 self.__buffer.fill(0)
754
768
755 self.__buffer_id = 0
769 self.__buffer_id = 0
756
770
757 self.__flagIsNewFile = 0
771 self.__flagIsNewFile = 0
758
772
759 self.flagIsNewBlock = 1
773 self.flagIsNewBlock = 1
760
774
761 self.nWriteBlocks += 1
775 self.nWriteBlocks += 1
762
776
763 self.__blocksCounter += 1
777 self.__blocksCounter += 1
764
778
765
779
766 def writeNextBlock(self):
780 def writeNextBlock(self):
767
781
768 if not(self.__setNewBlock()):
782 if not(self.__setNewBlock()):
769 return 0
783 return 0
770
784
771 self.__writeBlock()
785 self.__writeBlock()
772
786
773 return 1
787 return 1
774
788
775 def __hasAllDataInBuffer(self):
789 def __hasAllDataInBuffer(self):
776 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
790 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
777 return 1
791 return 1
778
792
779 return 0
793 return 0
780
794
781 def putData(self):
795 def putData(self):
796
782 self.flagIsNewBlock = 0
797 self.flagIsNewBlock = 0
783
798
784 if self.m_Voltage.flagNoData:
799 if self.m_Voltage.flagNoData:
785 return None
800 return 0
786
801
787 if self.m_Voltage.flagResetProcessing:
802 if self.m_Voltage.flagResetProcessing:
788 self.__buffer = numpy.array([],self.__dataType)
803
804 self.__buffer.fill(0)
805
789 self.__buffer_id = 0
806 self.__buffer_id = 0
790 self.__setNextFile()
807 self.__setNextFile()
791
808
792 self.__setHeaderByObj()
809 self.__buffer[self.__buffer_id,:,:] = self.m_Voltage.data
793
794 shape = self.m_Voltage.data.shape
795 data = numpy.zeros(shape,self.__dataType)
796
797 data['real'] = self.m_Voltage.data.real
798 data['imag'] = self.m_Voltage.data.imag
799
800 data = data.reshape((-1))
801
802 self.__buffer = numpy.hstack((self.__buffer,data))
803
810
804 self.__buffer_id += 1
811 self.__buffer_id += 1
805
812
806 if self.__hasAllDataInBuffer():
813 if self.__hasAllDataInBuffer():
814
815 self.__getHeader()
807 self.writeNextBlock()
816 self.writeNextBlock()
808
817
809
810 if self.noMoreFiles:
818 if self.noMoreFiles:
811 print 'Process finished'
819 #print 'Process finished'
812 return None
820 return 0
813
821
814 return 1
822 return 1
815
823
816 def __setHeaderByObj(self):
824 def __getHeader(self):
817 self.m_BasicHeader = self.m_Voltage.m_BasicHeader.copy()
825 self.m_BasicHeader = self.m_Voltage.m_BasicHeader.copy()
818 self.m_SystemHeader = self.m_Voltage.m_SystemHeader.copy()
826 self.m_SystemHeader = self.m_Voltage.m_SystemHeader.copy()
819 self.m_RadarControllerHeader = self.m_Voltage.m_RadarControllerHeader.copy()
827 self.m_RadarControllerHeader = self.m_Voltage.m_RadarControllerHeader.copy()
820 self.m_ProcessingHeader = self.m_Voltage.m_ProcessingHeader.copy()
828 self.m_ProcessingHeader = self.m_Voltage.m_ProcessingHeader.copy()
821 self.__dataType = self.m_Voltage.dataType
829 self.__dataType = self.m_Voltage.dataType
822
830
823 def __setHeaderByFile(self):
831 def __setHeaderByFile(self):
824
832
825 format = self.__format
833 format = self.__format
826 header = ['Basic','System','RadarController','Processing']
834 header = ['Basic','System','RadarController','Processing']
827
835
828 fmtFromFile = None
836 fmtFromFile = None
829 headerFromFile = None
837 headerFromFile = None
830
838
831
839
832 fileTable = self.__configHeaderFile
840 fileTable = self.__configHeaderFile
833
841
834 if os.access(fileTable, os.R_OK):
842 if os.access(fileTable, os.R_OK):
835 import re, string
843 import re, string
836
844
837 f = open(fileTable,'r')
845 f = open(fileTable,'r')
838 lines = f.read()
846 lines = f.read()
839 f.close()
847 f.close()
840
848
841 #Delete comments into expConfig
849 #Delete comments into expConfig
842 while 1:
850 while 1:
843
851
844 startComment = string.find(lines.lower(),'#')
852 startComment = string.find(lines.lower(),'#')
845 if startComment == -1:
853 if startComment == -1:
846 break
854 break
847 endComment = string.find(lines.lower(),'\n',startComment)
855 endComment = string.find(lines.lower(),'\n',startComment)
848 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
856 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
849
857
850 while expFromFile == None:
858 while expFromFile == None:
851
859
852 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
860 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
853 nextFmt = string.find(lines.lower(),'format',currFmt+10)
861 nextFmt = string.find(lines.lower(),'format',currFmt+10)
854
862
855 if currFmt == -1:
863 if currFmt == -1:
856 break
864 break
857 if nextFmt == -1:
865 if nextFmt == -1:
858 nextFmt = len(lines)-1
866 nextFmt = len(lines)-1
859
867
860 fmtTable = lines[currFmt:nextFmt]
868 fmtTable = lines[currFmt:nextFmt]
861 lines = lines[nextFmt:]
869 lines = lines[nextFmt:]
862
870
863 fmtRead = self.__getValueFromArg(fmtTable,'format')
871 fmtRead = self.__getValueFromArg(fmtTable,'format')
864 if fmtRead != format:
872 if fmtRead != format:
865 continue
873 continue
866 fmtFromFile = fmtRead
874 fmtFromFile = fmtRead
867
875
868 lines2 = fmtTable
876 lines2 = fmtTable
869
877
870 while headerFromFile == None:
878 while headerFromFile == None:
871
879
872 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
880 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
873 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
881 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
874
882
875 if currHeader == -1:
883 if currHeader == -1:
876 break
884 break
877 if nextHeader == -1:
885 if nextHeader == -1:
878 nextHeader = len(lines2)-1
886 nextHeader = len(lines2)-1
879
887
880 headerTable = lines2[currHeader:nextHeader]
888 headerTable = lines2[currHeader:nextHeader]
881 lines2 = lines2[nextHeader:]
889 lines2 = lines2[nextHeader:]
882
890
883 headerRead = self.__getValueFromArg(headerTable,'site')
891 headerRead = self.__getValueFromArg(headerTable,'site')
884 if not(headerRead in header):
892 if not(headerRead in header):
885 continue
893 continue
886 headerFromFile = headerRead
894 headerFromFile = headerRead
887
895
888 if headerRead == 'Basic':
896 if headerRead == 'Basic':
889 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
897 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
890 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
898 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
891 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
899 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
892 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
900 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
893 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
901 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
894 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
902 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
895 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
903 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
896 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
904 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
897
905
898 else:
906 else:
899 print "file access denied:%s"%fileTable
907 print "file access denied:%s"%fileTable
900 sys.exit(0)
908 sys.exit(0)
901
909
902 def setup(self,path,set=0,format='rawdata'):
910 def setup(self, path, set=0, format='rawdata'):
903
911
904
912
905 if format == 'hdf5':
913 if format == 'hdf5':
906 ext = '.hdf5'
914 ext = '.hdf5'
907 format = 'hdf5'
915 format = 'hdf5'
908 print 'call hdf5 library'
916 print 'call hdf5 library'
909 return 0
917 return 0
910
918
911 if format == 'rawdata':
919 if format == 'rawdata':
912 ext = '.r'
920 ext = '.r'
913 format = 'Jicamarca'
921 format = 'Jicamarca'
914
922
915 #call to config_headers
923 #call to config_headers
916 #self.__setHeaderByFile()
924 #self.__setHeaderByFile()
917 self.__setHeaderByObj()
925
918 self.__path = path
926 self.__path = path
919 self.__setFile = set - 1
927 self.__setFile = set - 1
920 self.__ext = ext
928 self.__ext = ext
921 self.__format = format
929 self.__format = format
922 self.__buffer = numpy.array([],self.__dataType)
923
930
924 if not(self.__setNextFile()):
931 self.__getHeader()
925 return 0
932 self.__shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
933 self.m_ProcessingHeader.numHeights,
934 self.m_SystemHeader.numChannels )
935
936 self.__buffer = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex'))
926
937
938 # if not(self.__setNextFile()):
939 # return 0
940 return 1
941
942
927
943
928
944
929 No newline at end of file
945
Show file before | Show file after | Hide comments
@@ -1,59 +1,74
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 import os, sys
7 import os, sys
8 import time, datetime
8 import time, datetime
9
9
10 from Model.Voltage import Voltage
10 from Model.Voltage import Voltage
11 from IO.VoltageIO import VoltageReader
11 from IO.VoltageIO import *
12 from Graphics.VoltagePlot import Osciloscope
12 from Graphics.VoltagePlot import Osciloscope
13
13
14 class TestSChain():
14 class TestSChain():
15
15
16
16
17 def __init__(self):
17 def __init__(self):
18 self.setValues()
18 self.setValues()
19 self.createObjects()
19 self.createObjects()
20 self.testSChain()
20 self.testSChain()
21 pass
21 pass
22
22
23 def setValues(self):
23 def setValues(self):
24
24
25 self.path = '/home/roj-idl71/Data/RAWDATA/DP_Faraday/'
25 self.path = '/home/roj-idl71/Data/RAWDATA/DP_Faraday/'
26 self.path = '/Users/danielangelsuarezmunoz/Documents/Projects/testWR'
26 self.path = '/Users/danielangelsuarezmunoz/Documents/Projects/testWR'
27 self.path = '/home/roj-idl71/Data/RAWDATA/IMAGING'
28 self.path = '/home/roj-idl71/tmp/data'
27 #self.path = '/remote/puma/2004_11/DVD/'
29 #self.path = '/remote/puma/2004_11/DVD/'
30
31 self.ppath = "/home/roj-idl71/tmp/data"
28 self.startDateTime = datetime.datetime(2004,5,1,17,49,0)
32 self.startDateTime = datetime.datetime(2004,5,1,17,49,0)
29 self.endDateTime = datetime.datetime(2012,5,1,18,10,0)
33 self.endDateTime = datetime.datetime(2012,5,1,18,10,0)
30
34
31 def createObjects(self):
35 def createObjects(self):
32
36
33 self.voltageObj = Voltage()
37 self.voltageObj = Voltage()
34 self.readerObj = VoltageReader(self.voltageObj)
38 self.readerObj = VoltageReader(self.voltageObj)
35 self.plotObj = Osciloscope(self.voltageObj)
39 self.plotObj = Osciloscope(self.voltageObj)
40 self.writerObj = VoltageWriter(self.voltageObj)
36
41
37 self.readerObj.setup(self.path, self.startDateTime, self.endDateTime)
42 if not(self.readerObj.setup(self.path, self.startDateTime, self.endDateTime)):
43 sys.exit(0)
44
45 if not(self.writerObj.setup(self.ppath)):
46 sys.exit(0)
38
47
39 def testSChain(self):
48 def testSChain(self):
40
49
50 ini = time.time()
41 while(True):
51 while(True):
42
43 self.readerObj.getData()
52 self.readerObj.getData()
44 self.plotObj.plotData(idProfile = 1, type='iq', ymin = -100, ymax = 100)
53 self.plotObj.plotData(idProfile = 1, type='iq', ymin = -100, ymax = 100)
45
54
46 if self.readerObj.flagResetProcessing:
55 # self.writerObj.putData()
47 print 'jump'
56
48
49 # if self.readerObj.flagIsNewBlock:
50 # print 'Block No %04d, Time: %s'%(self.readerObj.nReadBlocks,
51 # datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc))
52
53 if self.readerObj.noMoreFiles:
57 if self.readerObj.noMoreFiles:
54 break
58 break
55
59
60 if self.readerObj.flagIsNewBlock:
61 print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
62 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
63 fin = time.time()
64 print 'Tiempo de un bloque leido y escrito: [%6.5f]' %(fin - ini)
65 ini = time.time()
66
67
68
69
70
56 self.plotObj.end()
71 self.plotObj.end()
57
72
58 if __name__ == '__main__':
73 if __name__ == '__main__':
59 TestSChain() No newline at end of file
74 TestSChain()
General Comments 0
You need to be logged in to leave comments. Login now