##// END OF EJS Templates
schain
RSS
IO:...
Victor Sarmiento -
r59:4a1c54fb9a59
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,502 +1,431
1 '''
1 '''
2 File: SpectraIO.py
2 File: SpectraIO.py
3 Created on 20/02/2012
3 Created on 20/02/2012
4
4
5 @author $Author$
5 @author $Author$
6 @version $Id$
6 @version $Id$
7 '''
7 '''
8
8
9 import os, sys
9 import os, sys
10 import numpy
10 import numpy
11 import glob
11 import glob
12 import fnmatch
12 import fnmatch
13 import time, datetime
13 import time, datetime
14
14
15 path = os.path.split(os.getcwd())[0]
15 path = os.path.split(os.getcwd())[0]
16 sys.path.append(path)
16 sys.path.append(path)
17
17
18 from Model.JROHeader import *
18 from Model.JROHeader import *
19 from Model.Spectra import Spectra
19 from Model.Spectra import Spectra
20
20
21 from DataIO import JRODataReader
21 from DataIO import JRODataReader
22 from DataIO import JRODataWriter
22 from DataIO import JRODataWriter
23 from DataIO import isNumber
23 from DataIO import isNumber
24
24
25
25
26 class SpectraReader( JRODataReader ):
26 class SpectraReader( JRODataReader ):
27 """
27 """
28 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
28 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
29 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
29 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
30 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
30 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
31
31
32 pares * alturas * perfiles (Self Spectra)
33 canales * alturas * perfiles (Cross Spectra)
34 canales * alturas (DC Channels)
35
32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
36 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
33 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
37 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
34 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
38 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
35 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
39 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
36
40
37 Example:
41 Example:
38 dpath = "/home/myuser/data"
42 dpath = "/home/myuser/data"
39
43
40 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
44 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
41
45
42 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
46 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
43
47
44 readerObj = SpectraReader()
48 readerObj = SpectraReader()
45
49
46 readerObj.setup(dpath, startTime, endTime)
50 readerObj.setup(dpath, startTime, endTime)
47
51
48 while(True):
52 while(True):
49
53
50 readerObj.getData()
54 readerObj.getData()
51
55
52 print readerObj.m_Spectra.data
56 print readerObj.m_Spectra.data
53
57
54 if readerObj.noMoreFiles:
58 if readerObj.flagNoMoreFiles:
55 break
59 break
56
60
57 """
61 """
62 m_DataObj = None
63
64 data_spc = None
65 data_cspc = None
66 data_dc = None
67
68 nChannels = 0
69
70 nPairs = 0
58
71
72 pts2read_SelfSpectra = 0
73 pts2read_CrossSpectra = 0
74 pts2read_DCchannels = 0
59
75
60 def __init__(self,m_Spectra=None):
76 ext = ".pdata"
77
78
79 def __init__(self, m_Spectra=None):
61 """
80 """
62 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
81 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
63
82
64 Inputs:
83 Inputs:
65 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
84 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
66 almacenar un perfil de datos cada vez que se haga un requerimiento
85 almacenar un perfil de datos cada vez que se haga un requerimiento
67 (getData). El perfil sera obtenido a partir del buffer de datos,
86 (getData). El perfil sera obtenido a partir del buffer de datos,
68 si el buffer esta vacio se hara un nuevo proceso de lectura de un
87 si el buffer esta vacio se hara un nuevo proceso de lectura de un
69 bloque de datos.
88 bloque de datos.
70 Si este parametro no es pasado se creara uno internamente.
89 Si este parametro no es pasado se creara uno internamente.
71
90
72 Affected:
91 Affected:
73 self.m_DataObj
92 self.m_DataObj
74 self.m_BasicHeader
75 self.m_SystemHeader
76 self.m_RadarControllerHeader
77 self.m_ProcessingHeader
78
93
79 Return : None
94 Return : None
80 """
95 """
81 if m_Spectra == None:
96 if m_Spectra == None:
82 m_Spectra = Spectra()
97 m_Spectra = Spectra()
83
98
84 if not( isinstance(m_Spectra, Spectra) ):
99 if not( isinstance(m_Spectra, Spectra) ):
85 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
100 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
86
87 self.m_DataObj = m_Spectra
88
89 self.m_BasicHeader = BasicHeader()
90
91 self.m_SystemHeader = SystemHeader()
92
93 self.m_RadarControllerHeader = RadarControllerHeader()
94
95 self.m_ProcessingHeader = ProcessingHeader()
96
97 self.fp = None
98
99 self.idFile = None
100
101 self.startDateTime = None
102
103 self.endDateTime = None
104
105 self.dataType = None
106
107 self.fileSizeByHeader = 0
108
109 self.pathList = []
110
111 self.filenameList = []
112
113 self.lastUTTime = 0
114
115 self.maxTimeStep = 30
116
117 self.flagIsNewFile = 0
118
119 self.flagResetProcessing = 0
120
121 self.flagIsNewBlock = 0
122
123 self.noMoreFiles = 0
124
125 self.nReadBlocks = 0
126
127 self.online = 0
128
129 self.firstHeaderSize = 0
130
131 self.basicHeaderSize = 24
132
133 self.filename = None
134
135 self.fileSize = None
136
137 self.data_spc = None
138 self.data_cspc = None
139 self.data_dc = None
140
101
141 self.nChannels = 0
102 self.m_DataObj = m_Spectra
142 self.nPairs = 0
143
144 self.pts2read_SelfSpectra = 0
145 self.pts2read_CrossSpectra = 0
146 self.pts2read_DCchannels = 0
147 self.blocksize = 0
148
149 self.datablockIndex = 0
150
151 self.ippSeconds = 0
152
153 self.nSelfChannels = 0
154
155 self.nCrossPairs = 0
156
157 self.datablock_id = 9999
158
103
159 self.delay = 2 #seconds
160 self.nTries = 3 #quantity tries
161 self.nFiles = 3 #number of files for searching
162 self.year = 0
163 self.doy = 0
164 self.set = 0
165 self.ext = ".pdata"
166 self.path = None
167 self.optchar = "P"
168 self.nBlocks = 0
169
104
170 def hasNotDataInBuffer(self):
105 def __hasNotDataInBuffer(self):
171 return 1
106 return 1
172
107
108
173 def getBlockDimension(self):
109 def getBlockDimension(self):
110 """
111 Obtiene la cantidad de puntos a leer por cada bloque de datos
174
112
113 Affected:
114 self.nChannels
115 self.nPairs
116 self.pts2read_SelfSpectra
117 self.pts2read_CrossSpectra
118 self.pts2read_DCchannels
119 self.blocksize
120 self.m_DataObj.nChannels
121 self.m_DataObj.nPairs
122
123 Return:
124 None
125 """
175 self.nChannels = 0
126 self.nChannels = 0
176 self.nPairs = 0
127 self.nPairs = 0
177
128
178 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
129 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
179 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
130 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
180 self.nChannels = self.nChannels + 1
131 self.nChannels = self.nChannels + 1
181 else:
132 else:
182 self.nPairs = self.nPairs + 1
133 self.nPairs = self.nPairs + 1
183
134
184 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights
135 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights
185 self.pts2read_SelfSpectra = int( pts2read * self.nChannels )
136 self.pts2read_SelfSpectra = int( pts2read * self.nChannels )
186 self.pts2read_CrossSpectra = int( pts2read * self.nPairs )
137 self.pts2read_CrossSpectra = int( pts2read * self.nPairs )
187 self.pts2read_DCchannels = int( self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels )
138 self.pts2read_DCchannels = int( self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels )
188
139
189 self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
140 self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
190
141
191 self.m_DataObj.nChannels = self.nChannels
142 self.m_DataObj.nChannels = self.nChannels
192 self.m_DataObj.nPairs = self.nPairs
143 self.m_DataObj.nPairs = self.nPairs
144
193
145
194 def readBlock(self):
146 def readBlock(self):
195 """
147 """
196 Lee el bloque de datos desde la posicion actual del puntero del archivo
148 Lee el bloque de datos desde la posicion actual del puntero del archivo
197 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
149 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
198 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
150 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
199 es seteado a 0
151 es seteado a 0
200
152
201 Return: None
153 Return: None
202
154
203 Variables afectadas:
155 Variables afectadas:
204 self.datablockIndex
156 self.datablockIndex
205 self.flagIsNewFile
157 self.flagIsNewFile
206 self.flagIsNewBlock
158 self.flagIsNewBlock
207 self.nReadBlocks
159 self.nReadBlocks
208 self.data_spc
160 self.data_spc
209 self.data_cspc
161 self.data_cspc
210 self.data_dc
162 self.data_dc
211
163
212 Exceptions:
164 Exceptions:
213 Si un bloque leido no es un bloque valido
165 Si un bloque leido no es un bloque valido
214 """
166 """
215 #self.datablock_id = 0
216 #self.flagIsNewFile = 0
217 #self.flagIsNewBlock = 1
218
219 blockOk_flag = False
167 blockOk_flag = False
220 fpointer = self.fp.tell()
168 fpointer = self.fp.tell()
221
169
222 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
170 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
223 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
171 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
224 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
172 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
225
173
226 if self.online:
174 if self.online:
227 if (spc.size + cspc.size + dc.size) != self.blocksize:
175 if (spc.size + cspc.size + dc.size) != self.blocksize:
228 for nTries in range( self.nTries ):
176 for nTries in range( self.nTries ):
229 #nTries = 0
177 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
230 #while( nTries < self.nTries ):
231 #nTries += 1
232 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
233 time.sleep( self.delay )
178 time.sleep( self.delay )
234 self.fp.seek( fpointer )
179 self.fp.seek( fpointer )
235 fpointer = self.fp.tell()
180 fpointer = self.fp.tell()
236 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
181 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
237 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
182 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
238 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
183 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
239
184
240 if (spc.size + cspc.size + dc.size) == self.blocksize:
185 if (spc.size + cspc.size + dc.size) == self.blocksize:
241 blockOk_flag = True
186 blockOk_flag = True
242 break
187 break
243 #if (spc.size + cspc.size + dc.size) == self.blocksize:
244 # nTries = 0
245 # break
246 if not( blockOk_flag ):
188 if not( blockOk_flag ):
247 return 0
189 return 0
248 #if nTries > 0:
249 # return 0
250
190
251 try:
191 try:
252 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
192 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
253 cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
193 cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
254 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
194 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
255 except:
195 except:
256 print "Data file %s is invalid" % self.filename
196 print "Data file %s is invalid" % self.filename
257 return 0
197 return 0
258
198
259 if not( self.m_ProcessingHeader.shif_fft ):
199 if not( self.m_ProcessingHeader.shif_fft ):
260 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
200 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
261 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
201 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
262
202
263 spc = numpy.transpose( spc, (0,2,1) )
203 spc = numpy.transpose( spc, (0,2,1) )
264 cspc = numpy.transpose( cspc, (0,2,1) )
204 cspc = numpy.transpose( cspc, (0,2,1) )
265 #dc = numpy.transpose(dc, (0,2,1))
205 #dc = numpy.transpose(dc, (0,2,1))
266
206
267 self.data_spc = spc
207 self.data_spc = spc
268 self.data_cspc = cspc['real'] + cspc['imag']*1j
208 self.data_cspc = cspc['real'] + cspc['imag']*1j
269 self.data_dc = dc['real'] + dc['imag']*1j
209 self.data_dc = dc['real'] + dc['imag']*1j
270
210
271 self.datablock_id = 0
211 self.datablockIndex = 0
272 self.flagIsNewFile = 0
212 self.flagIsNewFile = 0
273 self.flagIsNewBlock = 1
213 self.flagIsNewBlock = 1
274
214
275 self.nReadBlocks += 1
215 self.nReadBlocks += 1
276 self.nBlocks += 1
216 self.nBlocks += 1
277
217
278 return 1
218 return 1
279
219
220
280 def getData(self):
221 def getData(self):
281 """
222 """
282 Copia el buffer de lectura a la clase "Spectra",
223 Copia el buffer de lectura a la clase "Spectra",
283 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
224 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
284 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
225 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
285
226
286 Return:
227 Return:
287 0 : Si no hay mas archivos disponibles
228 0 : Si no hay mas archivos disponibles
288 1 : Si hizo una buena copia del buffer
229 1 : Si hizo una buena copia del buffer
289
230
290 Affected:
231 Affected:
291 self.m_DataObj
232 self.m_DataObj
292 self.datablockIndex
233 self.datablockIndex
293 self.flagResetProcessing
234 self.flagResetProcessing
294 self.flagIsNewBlock
235 self.flagIsNewBlock
295 """
236 """
296
237
238 if self.flagNoMoreFiles: return 0
239
297 self.flagResetProcessing = 0
240 self.flagResetProcessing = 0
298 self.flagIsNewBlock = 0
241 self.flagIsNewBlock = 0
299
242
300 if self.hasNotDataInBuffer():
243 if self.__hasNotDataInBuffer():
301
244
302 if not( self.readNextBlock() ):
245 if not( self.readNextBlock() ):
303 self.setNextFile()
246 self.setNextFile()
304 return 0
247 return 0
305
248
306 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
249 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
307 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
250 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
308 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
251 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
309 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
252 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
310 self.m_DataObj.heights = self.heights
253 self.m_DataObj.heights = self.heights
311 self.m_DataObj.dataType = self.dataType
254 self.m_DataObj.dataType = self.dataType
312
255
313 if self.noMoreFiles == 1:
256 if self.flagNoMoreFiles == 1:
314 print 'Process finished'
257 print 'Process finished'
315 return 0
258 return 0
316
259
317 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
260 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
318
261
319 if self.data_dc == None:
262 if self.data_dc == None:
320 self.m_Voltage.flagNoData = True
263 self.m_DataObj.flagNoData = True
321 return 0
264 return 0
322
265
323 self.m_DataObj.flagNoData = False
266 self.m_DataObj.flagNoData = False
324 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
267 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
325
268
326 self.m_DataObj.data_spc = self.data_spc
269 self.m_DataObj.data_spc = self.data_spc
327 self.m_DataObj.data_cspc = self.data_cspc
270 self.m_DataObj.data_cspc = self.data_cspc
328 self.m_DataObj.data_dc = self.data_dc
271 self.m_DataObj.data_dc = self.data_dc
329
272
330 #call setData - to Data Object
273 #call setData - to Data Object
331 #self.datablock_id += 1
274 #self.datablockIndex += 1
332 #self.idProfile += 1
275 #self.idProfile += 1
333
276
334 return 1
277 return 1
335
278
336 class SpectraWriter( JRODataWriter ):
279
280 class SpectraWriter(JRODataWriter):
281
337 """
282 """
338 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
283 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
339 de los datos siempre se realiza por bloques.
284 de los datos siempre se realiza por bloques.
340 """
285 """
341
286
342 def __init__(self,m_Spectra=None):
287 m_DataObj = None
288
289 ext = ".pdata"
290
291 optchar = "P"
292
293 shape_spc_Buffer = None
294 shape_cspc_Buffer = None
295 shape_dc_Buffer = None
296
297
298 def __init__(self, m_Spectra=None):
343 """
299 """
344 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
300 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
345
301
346 Affected:
302 Affected:
347 self.m_DataObj
303 self.m_DataObj
348 self.m_BasicHeader
304 self.m_BasicHeader
349 self.m_SystemHeader
305 self.m_SystemHeader
350 self.m_RadarControllerHeader
306 self.m_RadarControllerHeader
351 self.m_ProcessingHeader
307 self.m_ProcessingHeader
352
308
353 Return: None
309 Return: None
354 """
310 """
355
356 if m_Spectra == None:
311 if m_Spectra == None:
357 m_Spectra = Spectra()
312 m_Spectra = Spectra()
358
313
314 if not( isinstance(m_Spectra, Spectra) ):
315 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
316
359 self.m_DataObj = m_Spectra
317 self.m_DataObj = m_Spectra
360
361 self.fp = None
362
363 self.format = None
364
365 self.blocksCounter = 0
366
367 self.setFile = None
368
369 self.flagIsNewFile = 1
370
371 self.dataType = None
372
373 self.ext = ".pdata"
374
375 self.path = None
376
377 self.optchar = "P"
378
379 self.shape_spc_Buffer = None
380 self.shape_cspc_Buffer = None
381 self.shape_dc_Buffer = None
382
383 self.nWriteBlocks = 0
384
385 self.flagIsNewBlock = 0
386
387 self.noMoreFiles = 0
388
389 self.filename = None
390
391 self.m_BasicHeader= BasicHeader()
392
393 self.m_SystemHeader = SystemHeader()
394
395 self.m_RadarControllerHeader = RadarControllerHeader()
396
397 self.m_ProcessingHeader = ProcessingHeader()
398
399 self.data_spc = None
400 self.data_cspc = None
401 self.data_dc = None
402
318
319
403 def hasAllDataInBuffer(self):
320 def hasAllDataInBuffer(self):
404 return 1
321 return 1
322
405
323
406 def setBlockDimension(self):
324 def setBlockDimension(self):
325 """
326 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
327
328 Affected:
329 self.shape_spc_Buffer
330 self.shape_cspc_Buffer
331 self.shape_dc_Buffer
407
332
333 Return: None
334 """
408 self.shape_spc_Buffer = (self.m_DataObj.nChannels,
335 self.shape_spc_Buffer = (self.m_DataObj.nChannels,
409 self.m_ProcessingHeader.numHeights,
336 self.m_ProcessingHeader.numHeights,
410 self.m_ProcessingHeader.profilesPerBlock)
337 self.m_ProcessingHeader.profilesPerBlock)
411
338
412 self.shape_cspc_Buffer = (self.m_DataObj.nPairs,
339 self.shape_cspc_Buffer = (self.m_DataObj.nPairs,
413 self.m_ProcessingHeader.numHeights,
340 self.m_ProcessingHeader.numHeights,
414 self.m_ProcessingHeader.profilesPerBlock)
341 self.m_ProcessingHeader.profilesPerBlock)
415
342
416 self.shape_dc_Buffer = (self.m_SystemHeader.numChannels,
343 self.shape_dc_Buffer = (self.m_SystemHeader.numChannels,
417 self.m_ProcessingHeader.numHeights)
344 self.m_ProcessingHeader.numHeights)
418
345
419
346
420 def writeBlock(self):
347 def writeBlock(self):
421 """
348 """
422 Escribe el buffer en el file designado
349 Escribe el buffer en el file designado
423
350
424 Affected:
351 Affected:
425 self.data_spc
352 self.data_spc
426 self.data_cspc
353 self.data_cspc
427 self.data_dc
354 self.data_dc
428 self.flagIsNewFile
355 self.flagIsNewFile
429 self.flagIsNewBlock
356 self.flagIsNewBlock
430 self.nWriteBlocks
357 self.nWriteBlocks
431 self.blocksCounter
358 self.blocksCounter
432
359
433 Return: None
360 Return: None
434 """
361 """
435 spc = numpy.transpose( self.data_spc, (0,2,1) )
362 spc = numpy.transpose( self.data_spc, (0,2,1) )
436 if not( self.m_ProcessingHeader.shif_fft ):
363 if not( self.m_ProcessingHeader.shif_fft ):
437 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
364 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
438 data = spc.reshape((-1))
365 data = spc.reshape((-1))
439 data.tofile(self.fp)
366 data.tofile(self.fp)
440
367
441 data = numpy.zeros( self.shape_cspc_Buffer, self.dataType )
368 data = numpy.zeros( self.shape_cspc_Buffer, self.dataType )
442 cspc = numpy.transpose( self.data_cspc, (0,2,1) )
369 cspc = numpy.transpose( self.data_cspc, (0,2,1) )
443 if not( self.m_ProcessingHeader.shif_fft ):
370 if not( self.m_ProcessingHeader.shif_fft ):
444 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
371 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
445 data['real'] = cspc.real
372 data['real'] = cspc.real
446 data['imag'] = cspc.imag
373 data['imag'] = cspc.imag
447 data = data.reshape((-1))
374 data = data.reshape((-1))
448 data.tofile(self.fp)
375 data.tofile(self.fp)
449
376
450 data = numpy.zeros( self.shape_dc_Buffer, self.dataType )
377 data = numpy.zeros( self.shape_dc_Buffer, self.dataType )
451 dc = self.data_dc
378 dc = self.data_dc
452 data['real'] = dc.real
379 data['real'] = dc.real
453 data['imag'] = dc.imag
380 data['imag'] = dc.imag
454 data = data.reshape((-1))
381 data = data.reshape((-1))
455 data.tofile(self.fp)
382 data.tofile(self.fp)
456
383
457 self.data_spc.fill(0)
384 self.data_spc.fill(0)
458 self.data_cspc.fill(0)
385 self.data_cspc.fill(0)
459 self.data_dc.fill(0)
386 self.data_dc.fill(0)
460
387
461 self.flagIsNewFile = 0
388 self.flagIsNewFile = 0
462 self.flagIsNewBlock = 1
389 self.flagIsNewBlock = 1
463 self.nWriteBlocks += 1
390 self.nWriteBlocks += 1
464 self.blocksCounter += 1
391 self.blocksCounter += 1
465
392
393
466 def putData(self):
394 def putData(self):
467 """
395 """
468 Setea un bloque de datos y luego los escribe en un file
396 Setea un bloque de datos y luego los escribe en un file
469
397
470 Affected:
398 Affected:
471 self.data_spc
399 self.data_spc
472 self.data_cspc
400 self.data_cspc
473 self.data_dc
401 self.data_dc
474
402
475 Return:
403 Return:
476 0 : Si no hay data o no hay mas files que puedan escribirse
404 0 : Si no hay data o no hay mas files que puedan escribirse
477 1 : Si se escribio la data de un bloque en un file
405 1 : Si se escribio la data de un bloque en un file
478 """
406 """
479 self.flagIsNewBlock = 0
407 self.flagIsNewBlock = 0
480
408
481 if self.m_DataObj.flagNoData:
409 if self.m_DataObj.flagNoData:
482 return 0
410 return 0
483
411
484 if self.m_DataObj.flagResetProcessing:
412 if self.m_DataObj.flagResetProcessing:
485 self.data_spc.fill(0)
413 self.data_spc.fill(0)
486 self.data_cspc.fill(0)
414 self.data_cspc.fill(0)
487 self.data_dc.fill(0)
415 self.data_dc.fill(0)
488 self.setNextFile()
416 self.setNextFile()
489
417
490 self.data_spc = self.m_DataObj.data_spc
418 self.data_spc = self.m_DataObj.data_spc
491 self.data_cspc = self.m_DataObj.data_cspc
419 self.data_cspc = self.m_DataObj.data_cspc
492 self.data_dc = self.m_DataObj.data_dc
420 self.data_dc = self.m_DataObj.data_dc
493
421
422 # #self.m_ProcessingHeader.dataBlocksPerFile)
494 if True:
423 if True:
495 self.getHeader()
424 self.getHeader()
496 self.writeNextBlock()
425 self.writeNextBlock()
497
426
498 if self.noMoreFiles:
427 if self.flagNoMoreFiles:
499 #print 'Process finished'
428 #print 'Process finished'
500 return 0
429 return 0
501
430
502 return 1 No newline at end of file
431 return 1
Show file before | Show file after | Hide comments
@@ -1,464 +1,388
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 Model.JROHeader import *
17 from Model.JROHeader import *
18 from Model.Voltage import Voltage
18 from Model.Voltage import Voltage
19
19
20 from IO.DataIO import JRODataReader
20 from IO.DataIO import JRODataReader
21 from IO.DataIO import JRODataWriter
21 from IO.DataIO import JRODataWriter
22
22
23
23 class VoltageReader(JRODataReader):
24 class VoltageReader(JRODataReader):
24 """
25 """
25 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
26 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
26 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
27 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
27 perfiles*alturas*canales) son almacenados en la variable "buffer".
28 perfiles*alturas*canales) son almacenados en la variable "buffer".
28
29
30 Voltajes - perfiles * alturas * canales
31
29 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
30 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
33 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
31 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
34 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
32 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
35 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
33
36
34 Example:
37 Example:
35
38
36 dpath = "/home/myuser/data"
39 dpath = "/home/myuser/data"
37
40
38 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
41 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
39
42
40 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
43 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
41
44
42 readerObj = VoltageReader()
45 readerObj = VoltageReader()
43
46
44 readerObj.setup(dpath, startTime, endTime)
47 readerObj.setup(dpath, startTime, endTime)
45
48
46 while(True):
49 while(True):
47
50
48 #to get one profile
51 #to get one profile
49 profile = readerObj.getData()
52 profile = readerObj.getData()
50
53
51 #print the profile
54 #print the profile
52 print profile
55 print profile
53
56
54 #If you want to see all datablock
57 #If you want to see all datablock
55 print readerObj.datablock
58 print readerObj.datablock
56
59
57 if readerObj.noMoreFiles:
60 if readerObj.flagNoMoreFiles:
58 break
61 break
59
62
60 """
63 """
64 m_DataObj = None
65
66 idProfile = 0
67
68 datablock = None
69
70 ext = ".r"
71
72 pts2read = 0
73
74 utc = 0
61
75
62
76
63 def __init__(self,m_Voltage=None):
77 def __init__(self, m_Voltage=None):
64 """
78 """
65 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
79 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
66
80
67 Input:
81 Input:
68 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
82 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
69 almacenar un perfil de datos cada vez que se haga un requerimiento
83 almacenar un perfil de datos cada vez que se haga un requerimiento
70 (getData). El perfil sera obtenido a partir del buffer de datos,
84 (getData). El perfil sera obtenido a partir del buffer de datos,
71 si el buffer esta vacio se hara un nuevo proceso de lectura de un
85 si el buffer esta vacio se hara un nuevo proceso de lectura de un
72 bloque de datos.
86 bloque de datos.
73 Si este parametro no es pasado se creara uno internamente.
87 Si este parametro no es pasado se creara uno internamente.
74
88
75 Variables afectadas:
89 Variables afectadas:
76 self.m_DataObj
90 self.m_DataObj
77 self.m_BasicHeader
78 self.m_SystemHeader
79 self.m_RadarControllerHeader
80 self.m_ProcessingHeader
81
82
91
83 Return:
92 Return:
84 Void
93 None
85
86 """
94 """
87 if m_Voltage == None:
95 if m_Voltage == None:
88 m_Voltage = Voltage()
96 m_Voltage = Voltage()
89
97
90 if not(isinstance(m_Voltage, Voltage)):
98 if not(isinstance(m_Voltage, Voltage)):
91 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
99 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
92
100
93 self.m_DataObj = m_Voltage
101 self.m_DataObj = m_Voltage
94
95 self.m_BasicHeader = BasicHeader()
96
97 self.m_SystemHeader = SystemHeader()
98
99 self.m_RadarControllerHeader = RadarControllerHeader()
100
101 self.m_ProcessingHeader = ProcessingHeader()
102
103 self.fp = None
104
105 self.idFile = None
106
107 self.startDateTime = None
108
109 self.endDateTime = None
110
111 self.dataType = None
112
113 self.fileSizeByHeader = 0
114
115 self.pathList = []
116
117 self.filenameList = []
118
119 self.lastUTTime = 0
120
121 self.maxTimeStep = 30
122
123 self.flagIsNewFile = 0
124
125 self.ippSeconds = 0
126
127 self.flagResetProcessing = 0
128
129 self.flagIsNewBlock = 0
130
131 self.noMoreFiles = 0
132
133 self.nReadBlocks = 0
134
135 self.online = 0
136
137 self.filename = None
138
139 self.fileSize = None
140
141 self.firstHeaderSize = 0
142
143 self.basicHeaderSize = 24
144
145 self.idProfile = 0
146
147 self.datablock = None
148
149 self.datablockIndex = 9999
150
102
151 self.delay = 7 #seconds
152
153 self.nTries = 3 #quantity tries
154
155 self.nFiles = 3 #number of files for searching
156
157 self.year = 0
158
159 self.doy = 0
160
161 self.set = 0
162
163 self.ext = ".r"
164
165 self.path = None
166
167 self.optchar = "D"
168
169 self.pts2read = 0
170
171 self.blocksize = 0
172
173 self.utc = 0
174
175 self.nBlocks = 0
176
103
177 def hasNotDataInBuffer(self):
104 def __hasNotDataInBuffer(self):
178 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
105 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
179 return 1
106 return 1
180 return 0
107 return 0
181
108
109
182 def getBlockDimension(self):
110 def getBlockDimension(self):
111 """
112 Obtiene la cantidad de puntos a leer por cada bloque de datos
183
113
114 Affected:
115 self.pts2read
116 self.blocksize
117
118 Return:
119 None
120 """
184 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
121 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
185 self.blocksize = self.pts2read
122 self.blocksize = self.pts2read
123
186
124
187 def readBlock(self):
125 def readBlock(self):
188 """
126 """
189 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
127 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
190 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
128 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
191 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
129 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
192 es seteado a 0
130 es seteado a 0
193
131
194 Inputs:
132 Inputs:
195 None
133 None
196
134
197 Return:
135 Return:
198 None
136 None
199
137
200 Affected:
138 Affected:
201 self.datablockIndex
139 self.datablockIndex
202 self.datablock
140 self.datablock
203 self.flagIsNewFile
141 self.flagIsNewFile
204 self.idProfile
142 self.idProfile
205 self.flagIsNewBlock
143 self.flagIsNewBlock
206 self.nReadBlocks
144 self.nReadBlocks
207
145
208 Exceptions:
146 Exceptions:
209 Si un bloque leido no es un bloque valido
147 Si un bloque leido no es un bloque valido
210 """
148 """
211 blockOk_flag = False
149 blockOk_flag = False
212 fpointer = self.fp.tell()
150 fpointer = self.fp.tell()
213
151
214 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
152 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
215
153
216 if self.online:
154 if self.online:
217 if junk.size != self.blocksize:
155 if junk.size != self.blocksize:
218 for nTries in range( self.nTries ):
156 for nTries in range( self.nTries ):
219 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
157 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
220 time.sleep( self.delay )
158 time.sleep( self.delay )
221 self.fp.seek( fpointer )
159 self.fp.seek( fpointer )
222 fpointer = self.fp.tell()
160 fpointer = self.fp.tell()
223 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
161 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
224 if junk.size == self.blocksize:
162 if junk.size == self.blocksize:
225 blockOk_flag = True
163 blockOk_flag = True
226 break
164 break
227
165
228 if not( blockOk_flag ):
166 if not( blockOk_flag ):
229 return 0
167 return 0
230
168
231 try:
169 try:
232 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
170 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
233 except:
171 except:
234 print "Data file %s is invalid" % self.filename
172 print "Data file %s is invalid" % self.filename
235 return 0
173 return 0
236
174
237 #data = junk['real'] + junk['imag']*1j
175 #data = junk['real'] + junk['imag']*1j
238 self.datablock = junk['real'] + junk['imag']*1j
176 self.datablock = junk['real'] + junk['imag']*1j
239
177
240 self.datablockIndex = 0
178 self.datablockIndex = 0
241 self.flagIsNewFile = 0
179 self.flagIsNewFile = 0
242 self.idProfile = 0
180 self.idProfile = 0
243 self.flagIsNewBlock = 1
181 self.flagIsNewBlock = 1
244
182
245 self.nReadBlocks += 1
183 self.nReadBlocks += 1
246 self.nBlocks += 1
184 self.nBlocks += 1
247
185
248 return 1
186 return 1
187
249
188
250 def getData(self):
189 def getData(self):
251 """
190 """
252 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
191 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
253 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
192 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
254 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
193 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
255
194
256 Ademas incrementa el contador del buffer en 1.
195 Ademas incrementa el contador del buffer en 1.
257
196
258 Return:
197 Return:
259 data : retorna un perfil de voltages (alturas * canales) copiados desde el
198 data : retorna un perfil de voltages (alturas * canales) copiados desde el
260 buffer. Si no hay mas archivos a leer retorna None.
199 buffer. Si no hay mas archivos a leer retorna None.
261
200
262 Variables afectadas:
201 Variables afectadas:
263 self.m_DataObj
202 self.m_DataObj
264 self.datablockIndex
203 self.datablockIndex
265 self.idProfile
204 self.idProfile
266
205
267 Affected:
206 Affected:
268 self.m_DataObj
207 self.m_DataObj
269 self.datablockIndex
208 self.datablockIndex
270 self.flagResetProcessing
209 self.flagResetProcessing
271 self.flagIsNewBlock
210 self.flagIsNewBlock
272 self.idProfile
211 self.idProfile
273 """
212 """
274 if self.noMoreFiles: return 0
213 if self.flagNoMoreFiles: return 0
275
214
276 self.flagResetProcessing = 0
215 self.flagResetProcessing = 0
277 self.flagIsNewBlock = 0
216 self.flagIsNewBlock = 0
278
217
279 if self.hasNotDataInBuffer():
218 if self.__hasNotDataInBuffer():
280
219
281 if not( self.readNextBlock() ):
220 if not( self.readNextBlock() ):
282 self.setNextFile()
221 self.setNextFile()
283 return 0
222 return 0
284
223
285 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
224 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
286 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
225 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
287 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
226 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
288 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
227 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
289 self.m_DataObj.heights = self.heights
228 self.m_DataObj.heights = self.heights
290 self.m_DataObj.dataType = self.dataType
229 self.m_DataObj.dataType = self.dataType
291
230
292 if self.noMoreFiles == 1:
231 if self.flagNoMoreFiles == 1:
293 print 'Process finished'
232 print 'Process finished'
294 return 0
233 return 0
295
234
296 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
235 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
297
236
298 if self.datablock == None:
237 if self.datablock == None:
299 self.m_DataObj.flagNoData = True
238 self.m_DataObj.flagNoData = True
300 return 0
239 return 0
301
240
302 time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
241 time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
303 self.utc = time
242 self.utc = time
304 #self.m_DataObj.m_BasicHeader.utc = time
243 #self.m_DataObj.m_BasicHeader.utc = time
305
244
306 self.m_DataObj.flagNoData = False
245 self.m_DataObj.flagNoData = False
307 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
246 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
308
247
309 self.m_DataObj.data = self.datablock[self.datablockIndex,:,:]
248 self.m_DataObj.data = self.datablock[self.datablockIndex,:,:]
310 self.m_DataObj.idProfile = self.idProfile
249 self.m_DataObj.idProfile = self.idProfile
311
250
312 self.datablockIndex += 1
251 self.datablockIndex += 1
313 self.idProfile += 1
252 self.idProfile += 1
314
253
315 #call setData - to Data Object
254 #call setData - to Data Object
316
255
317 return 1 #self.m_DataObj.data
256 return 1 #self.m_DataObj.data
318
257
258
319 class VoltageWriter( JRODataWriter ):
259 class VoltageWriter( JRODataWriter ):
320 """
260 """
321 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
261 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
322 de los datos siempre se realiza por bloques.
262 de los datos siempre se realiza por bloques.
323 """
263 """
324 __configHeaderFile = 'wrSetHeadet.txt'
264 __configHeaderFile = 'wrSetHeadet.txt'
325
265
326 def __init__(self,m_Voltage=None):
266 m_DataObj = None
267
268 datablock = None
269
270 datablockIndex = 0
271
272 ext = ".r"
273
274 optchar = "D"
275
276 shapeBuffer = None
277
278
279 def __init__(self, m_Voltage=None):
327 """
280 """
328 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
281 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
329
282
330 Affected:
283 Affected:
331 self.m_DataObj
284 self.m_DataObj
332 self.m_BasicHeader
333 self.m_SystemHeader
334 self.m_RadarControllerHeader
335 self.m_ProcessingHeader
336
285
337 Return: None
286 Return: None
338 """
287 """
339 if m_Voltage == None:
288 if m_Voltage == None:
340 m_Voltage = Voltage()
289 m_Voltage = Voltage()
341
290
291 if not( isinstance(m_Voltage, Voltage) ):
292 raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
293
342 self.m_DataObj = m_Voltage
294 self.m_DataObj = m_Voltage
343
295
344 self.fp = None
345
346 self.format = None
347
348 self.blocksCounter = 0
349
350 self.setFile = None
351
352 self.flagIsNewFile = 1
353
354 self.datablock = None
355
356 self.datablockIndex = 0
357
358 self.dataType = None
359
360 self.ext = ".r"
361
362 self.path = None
363
364 self.optchar = "D"
365
366 self.shapeBuffer = None
367
368 self.nWriteBlocks = 0
369
370 self.flagIsNewBlock = 0
371
372 self.noMoreFiles = 0
373
374 self.filename = None
375
376 self.m_BasicHeader= BasicHeader()
377
378 self.m_SystemHeader = SystemHeader()
379
380 self.m_RadarControllerHeader = RadarControllerHeader()
381
382 self.m_ProcessingHeader = ProcessingHeader()
383
296
384 def hasAllDataInBuffer(self):
297 def hasAllDataInBuffer(self):
385 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
298 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
386 return 1
299 return 1
387 return 0
300 return 0
388
301
302
389 def setBlockDimension(self):
303 def setBlockDimension(self):
390
304 """
391 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
305 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
392 self.m_ProcessingHeader.numHeights,
306
393 self.m_SystemHeader.numChannels )
307 Affected:
308 self.shape_spc_Buffer
309 self.shape_cspc_Buffer
310 self.shape_dc_Buffer
311
312 Return: None
313 """
314 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
315 self.m_ProcessingHeader.numHeights,
316 self.m_SystemHeader.numChannels )
394
317
395 self.datablock = numpy.zeros(self.shapeBuffer, numpy.dtype('complex'))
318 self.datablock = numpy.zeros(self.shapeBuffer, numpy.dtype('complex'))
319
396
320
397 def writeBlock(self):
321 def writeBlock(self):
398 """
322 """
399 Escribe el buffer en el file designado
323 Escribe el buffer en el file designado
400
324
401 Affected:
325 Affected:
402 self.datablockIndex
326 self.datablockIndex
403 self.flagIsNewFile
327 self.flagIsNewFile
404 self.flagIsNewBlock
328 self.flagIsNewBlock
405 self.nWriteBlocks
329 self.nWriteBlocks
406 self.blocksCounter
330 self.blocksCounter
407
331
408 Return: None
332 Return: None
409 """
333 """
410 data = numpy.zeros( self.shapeBuffer, self.dataType )
334 data = numpy.zeros( self.shapeBuffer, self.dataType )
411
335
412 data['real'] = self.datablock.real
336 data['real'] = self.datablock.real
413 data['imag'] = self.datablock.imag
337 data['imag'] = self.datablock.imag
414
338
415 data = data.reshape( (-1) )
339 data = data.reshape( (-1) )
416
340
417 data.tofile( self.fp )
341 data.tofile( self.fp )
418
342
419 self.datablock.fill(0)
343 self.datablock.fill(0)
420 self.datablockIndex = 0
344 self.datablockIndex = 0
421 self.flagIsNewFile = 0
345 self.flagIsNewFile = 0
422 self.flagIsNewBlock = 1
346 self.flagIsNewBlock = 1
423 self.nWriteBlocks += 1
347 self.nWriteBlocks += 1
424 self.blocksCounter += 1
348 self.blocksCounter += 1
425
349
350
426 def putData(self):
351 def putData(self):
427 """
352 """
428 Setea un bloque de datos y luego los escribe en un file
353 Setea un bloque de datos y luego los escribe en un file
429
354
430 Affected:
355 Affected:
431 self.flagIsNewBlock
356 self.flagIsNewBlock
432 self.datablockIndex
357 self.datablockIndex
433
358
434 Return:
359 Return:
435 0 : Si no hay data o no hay mas files que puedan escribirse
360 0 : Si no hay data o no hay mas files que puedan escribirse
436 1 : Si se escribio la data de un bloque en un file
361 1 : Si se escribio la data de un bloque en un file
437 """
362 """
438 self.flagIsNewBlock = 0
363 self.flagIsNewBlock = 0
439
364
440 if self.m_DataObj.flagNoData:
365 if self.m_DataObj.flagNoData:
441 return 0
366 return 0
442
367
443 if self.m_DataObj.flagResetProcessing:
368 if self.m_DataObj.flagResetProcessing:
444
369
445 self.datablock.fill(0)
370 self.datablock.fill(0)
446 self.datablockIndex = 0
371 self.datablockIndex = 0
447 self.setNextFile()
372 self.setNextFile()
448
373
449 self.datablock[self.datablockIndex,:,:] = self.m_DataObj.data
374 self.datablock[self.datablockIndex,:,:] = self.m_DataObj.data
450
375
451 self.datablockIndex += 1
376 self.datablockIndex += 1
452
377
453 if self.hasAllDataInBuffer():
378 if self.hasAllDataInBuffer():
379 #if self.flagIsNewFile:
454 self.getHeader()
380 self.getHeader()
455 self.writeNextBlock()
381 self.writeNextBlock()
456
382
457 if self.noMoreFiles:
383 if self.flagNoMoreFiles:
458 #print 'Process finished'
384 #print 'Process finished'
459 return 0
385 return 0
460
386
461 return 1
387 return 1
462
463
464 No newline at end of file
388
General Comments 0
You need to be logged in to leave comments. Login now