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