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