##// END OF EJS Templates
schain-jc
RSS
Metodos definidos para la clase SpectraIO
Miguel Valdez -
r21:9494438365fa
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,20 +1,353
1 1 '''
2 2 Created on 23/01/2012
3 3
4 4 @author $Author$
5 5 @version $Id$
6 6 '''
7 7
8 8 from Header import *
9 9 from DataIO import DataReader
10 10 from DataIO import DataWriter
11 11
12 12
13 13 class SpectraReader(DataReader):
14 def __init__(self):
15 pass
14 """
15 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
16 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
17 nFFTs*alturas*canales) son almacenados en la variable "buffer".
18
19 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
20 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
21 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
22 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
23
24 Example:
25
26 dpath = "/home/myuser/data"
27
28 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
29
30 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
31
32 readerObj = SpectraReader()
33
34 readerObj.setup(dpath, startTime, endTime)
35
36 while(True):
37
38 readerObj.getData()
39
40 print readerObj.m_Spectra.data
41
42 if readerObj.noMoreFiles:
43 break
44
45 """
46
47 #speed of light
48 __c = 3E8
49
50 def __init__(self, m_Spectra = None):
51 """
52 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
53
54 Input:
55 m_Spectra : Objeto de la clase Voltage. Este objeto sera utilizado para
56 almacenar un perfil de datos cada vez que se haga un requerimiento
57 (getData). El perfil sera obtenido a partir del buffer de datos,
58 si el buffer esta vacio se hara un nuevo proceso de lectura de un
59 bloque de datos.
60 Si este parametro no es pasado se creara uno internamente.
61
62 Variables afectadas:
63 self.m_Spectra
64 self.m_BasicHeader
65 self.m_SystemHeader
66 self.m_RadarControllerHeader
67 self.m_ProcessingHeader
68
69
70 Return:
71 Void
72
73 """
74 if m_Spectra == None:
75 m_Spectra = Voltage()
76
77 if not(isinstance(m_Spectra, Voltage)):
78 raise ValueError, "in VoltageReader, m_Spectra must be an Voltage class object"
79
80 self.m_Spectra = m_Spectra
81
82 self.m_BasicHeader = BasicHeader()
83
84 self.m_SystemHeader = SystemHeader()
85
86 self.m_RadarControllerHeader = RadarControllerHeader()
87
88 self.m_ProcessingHeader = ProcessingHeader()
89
90 self.__fp = None
91
92 self.__idFile = None
93
94 self.__startDateTime = None
95
96 self.__endDateTime = None
97
98 self.__dataType = None
99
100 self.__fileSizeByHeader = 0
101
102 self.__pathList = []
103
104 self.filenameList = []
105
106 self.__lastUTTime = 0
107
108 self.__maxTimeStep = 30
109
110 self.__flagIsNewFile = 0
111
112 self.__ippSeconds = 0
113
114 self.flagResetProcessing = 0
115
116 self.flagIsNewBlock = 0
117
118 self.noMoreFiles = 0
119
120 self.nReadBlocks = 0
121
122 self.online = 0
123
124 self.filename = None
125
126 self.fileSize = None
127
128 self.firstHeaderSize = 0
129
130 self.basicHeaderSize = 24
131
132 self.idProfile = 0
133
134 self.__buffer = 0
135
136 self.__buffer_id = 9999
137
138 def __rdSystemHeader(self,fp=None):
139 if fp == None:
140 fp = self.__fp
141
142 self.m_SystemHeader.read(fp)
143
144 def __rdRadarControllerHeader(self,fp=None):
145 if fp == None:
146 fp = self.__fp
147
148 self.m_RadarControllerHeader.read(fp)
149
150 def __rdProcessingHeader(self,fp=None):
151 if fp == None:
152 fp = self.__fp
153
154 self.m_ProcessingHeader.read(fp)
155
156 def __rdBasicHeader(self, fp=None):
157
158 if fp == None:
159 fp = self.__fp
160
161 self.m_BasicHeader.read(fp)
162
163 def __readFirstHeader(self):
164
165 self.__rdBasicHeader()
166 self.__rdSystemHeader()
167 self.__rdRadarControllerHeader()
168 self.__rdProcessingHeader()
169 self.firstHeaderSize = self.m_BasicHeader.size
170
171 def __setNextFileOnline(self):
172 return 1
173
174 def __setNextFileOffline(self):
175
176 return 1
177
178 def __setNextFile(self):
179
180
181
182 return 1
183
184 def __setNewBlock(self):
185
186
187 return 1
188
189 def __readBlock(self):
190 """
191 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
192 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
193 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
194 es seteado a 0
195
196
197 Inputs:
198 None
199
200 Return:
201 None
202
203 Variables afectadas:
204
205 self.__buffer_id
206
207 self.__buffer
208
209 self.__flagIsNewFile
210
211 self.idProfile
212
213 self.flagIsNewBlock
214
215 self.nReadBlocks
216
217 """
218
219
220 def __hasNotDataInBuffer(self):
221
222
223 return 0
224
225 def __searchFiles(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata"):
226 """
227 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
228 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
229 correcta la estructura de directorios debe ser la siguiente:
230
231 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
232
233 [yyyy]: anio
234 [ddd] : dia del anio
235 [sss] : set del archivo
236
237 Inputs:
238 path : Directorio de datos donde se realizara la busqueda. Todos los
239 ficheros que concidan con el criterio de busqueda seran
240 almacenados en una lista y luego retornados.
241 startDateTime : Fecha inicial. Rechaza todos los archivos donde
242 file end time < startDateTime (obejto datetime.datetime)
243
244 endDateTime : Fecha final. Rechaza todos los archivos donde
245 file start time > endDateTime (obejto datetime.datetime)
246
247 set : Set del primer archivo a leer. Por defecto None
248
249 expLabel : Nombre del subdirectorio de datos. Por defecto ""
250
251 ext : Extension de los archivos a leer. Por defecto .r
252
253 Return:
254
255 (pathList, filenameList)
256
257 pathList : Lista de directorios donde se encontraron archivos dentro
258 de los parametros especificados
259 filenameList : Lista de archivos (ruta completa) que coincidieron con los
260 parametros especificados.
261
262 Variables afectadas:
263
264 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
265 como fuente para leer los bloque de datos, si se termina
266 de leer todos los bloques de datos de un determinado
267 archivo se pasa al siguiente archivo de la lista.
268
269 Excepciones:
270
271 """
272
273
274
275 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0):
276 """
277 setup configura los parametros de lectura de la clase VoltageReader.
278
279 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
280 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
281 self.filenameList.
282
283 Input:
284 path : Directorios donde se ubican los datos a leer. Dentro de este
285 directorio deberia de estar subdirectorios de la forma:
286
287 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
288
289 startDateTime : Fecha inicial. Rechaza todos los archivos donde
290 file end time < startDatetime (obejto datetime.datetime)
291
292 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
293 file end time < startDatetime (obejto datetime.datetime)
294
295 set : Set del primer archivo a leer. Por defecto None
296
297 expLabel : Nombre del subdirectorio de datos. Por defecto ""
298
299 ext : Extension de los archivos a leer. Por defecto .r
300
301 online :
302
303 Return:
304
305 Affected:
306
307 Excepciones:
308
309 Example:
310
311 """
312
313
314 def readNextBlock(self):
315 """
316 readNextBlock establece un nuevo bloque de datos a leer y los lee, si es que no existiese
317 mas bloques disponibles en el archivo actual salta al siguiente.
318
319 """
320
321
322 return 1
323
324 def getData(self):
325 """
326 getData copia el buffer de lectura a la clase "Spectra",
327 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
328 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
329
330
331 Inputs:
332 None
333
334 Return:
335 data : retorna un bloque de datos (nFFTs * alturas * canales) copiados desde el
336 buffer. Si no hay mas archivos a leer retorna None.
337
338 Variables afectadas:
339 self.m_Spectra
340 self.__buffer_id
341 self.idProfile
342
343 Excepciones:
344
345 """
346
347
348 return data
16 349
17 350 class SpectraWriter(DataWriter):
18 351 def __init__(self):
19 352 pass
20 353
General Comments 0
You need to be logged in to leave comments. Login now