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