##// END OF EJS Templates
schain-jc
RSS
Hasta el momento se realiza la lectura de Rawdata
Daniel Valdez -
r121:65ae6ea47e4e
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,60
1 import os, sys
2 import numpy
3
4 path = os.path.split(os.getcwd())[0]
5 sys.path.append(path)
6
7 from JROData import JROData
8 from IO.JROHeader import SystemHeader, RadarControllerHeader
9
10 class Spectra(JROData):
11 data_spc = None
12
13 data_cspc = None
14
15 data_dc = None
16
17 nFFTPoints = None
18
19 nPairs = None
20
21 pairsList = None
22
23 nIncohInt = None
24
25 def __init__(self):
26 '''
27 Constructor
28 '''
29
30 self.m_RadarControllerHeader = RadarControllerHeader()
31
32 self.m_SystemHeader = SystemHeader()
33
34 self.type = "Spectra"
35
36 #data es un numpy array de 2 dmensiones ( canales, alturas)
37 # self.data = None
38
39 self.dtype = None
40
41 self.nChannels = 0
42
43 self.nHeights = 0
44
45 self.nProfiles = None
46
47 self.heightList = None
48
49 self.channelList = None
50
51 self.channelIndexList = None
52
53 self.flagNoData = True
54
55 self.flagTimeBlock = False
56
57 self.dataUtcTime = None
58
59 self.nIncohInt = None
60 No newline at end of file
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (539 lines changed) Show them Hide them
@@ -0,0 +1,539
1 '''
2 File: SpectraIO.py
3 Created on 20/02/2012
4
5 @author $Author: dsuarez $
6 @version $Id: SpectraIO.py 110 2012-07-19 15:18:18Z dsuarez $
7 '''
8
9 import os, sys
10 import numpy
11 import glob
12 import fnmatch
13 import time, datetime
14
15 path = os.path.split(os.getcwd())[0]
16 sys.path.append(path)
17
18 from Model.JROHeader import *
19 from Model.Spectra import Spectra
20
21 from JRODataIO import JRODataReader
22 from JRODataIO import JRODataWriter
23 from JRODataIO import isNumber
24
25
26 class SpectraReader(JRODataReader):
27 """
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)
30 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
31
32 paresCanalesIguales * alturas * perfiles (Self Spectra)
33 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
34 canales * alturas (DC Channels)
35
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
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".
40
41 Example:
42 dpath = "/home/myuser/data"
43
44 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
45
46 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
47
48 readerObj = SpectraReader()
49
50 readerObj.setup(dpath, startTime, endTime)
51
52 while(True):
53
54 readerObj.getData()
55
56 print readerObj.dataOutObj.data
57
58 if readerObj.flagNoMoreFiles:
59 break
60
61 """
62 dataOutObj = None
63
64 datablock = None
65
66 pts2read_SelfSpectra = 0
67
68 pts2read_CrossSpectra = 0
69
70 pts2read_DCchannels = 0
71
72 ext = ".pdata"
73
74 optchar = "P"
75
76 flag_cspc = False
77
78 def __init__(self, dataOutObj=None):
79 """
80 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
81
82 Inputs:
83 dataOutObj : Objeto de la clase Spectra. Este objeto sera utilizado para
84 almacenar un perfil de datos cada vez que se haga un requerimiento
85 (getData). El perfil sera obtenido a partir del buffer de datos,
86 si el buffer esta vacio se hara un nuevo proceso de lectura de un
87 bloque de datos.
88 Si este parametro no es pasado se creara uno internamente.
89
90 Affected:
91 self.dataOutObj
92
93 Return : None
94 """
95
96 self.pts2read_SelfSpectra = 0
97
98 self.pts2read_CrossSpectra = 0
99
100 self.pts2read_DCs = 0
101
102 self.datablock = None
103
104 self.utc = None
105
106 self.ext = ".pdata"
107
108 self.optchar = "P"
109
110 self.basicHeaderObj = BasicHeader()
111
112 self.systemHeaderObj = SystemHeader()
113
114 self.radarControllerHeaderObj = RadarControllerHeader()
115
116 self.processingHeaderObj = ProcessingHeader()
117
118 self.online = 0
119
120 self.fp = None
121
122 self.idFile = None
123
124 self.dtype = None
125
126 self.fileSizeByHeader = None
127
128 self.filenameList = []
129
130 self.filename = None
131
132 self.fileSize = None
133
134 self.firstHeaderSize = 0
135
136 self.basicHeaderSize = 24
137
138 self.pathList = []
139
140 self.lastUTTime = 0
141
142 self.maxTimeStep = 30
143
144 self.flagNoMoreFiles = 0
145
146 self.set = 0
147
148 self.path = None
149
150 self.delay = 3 #seconds
151
152 self.nTries = 3 #quantity tries
153
154 self.nFiles = 3 #number of files for searching
155
156 self.nReadBlocks = 0
157
158 self.flagIsNewFile = 1
159
160 self.ippSeconds = 0
161
162 self.flagTimeBlock = 0
163
164 self.flagIsNewBlock = 0
165
166 self.nTotalBlocks = 0
167
168 self.blocksize = 0
169
170
171 def createObjByDefault(self):
172
173 dataObj = Spectra()
174
175 return dataObj
176
177 def __hasNotDataInBuffer(self):
178 return 1
179
180
181 def getBlockDimension(self):
182 """
183 Obtiene la cantidad de puntos a leer por cada bloque de datos
184
185 Affected:
186 self.nChannels
187 self.nPairs
188 self.pts2read_SelfSpectra
189 self.pts2read_CrossSpectra
190 self.pts2read_DCchannels
191 self.blocksize
192 self.dataOutObj.nChannels
193 self.dataOutObj.nPairs
194
195 Return:
196 None
197 """
198 self.nChannels = 0
199 self.nPairs = 0
200 self.pairList = []
201
202 for i in range( 0, self.processingHeaderObj.totalSpectra*2, 2 ):
203 if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
204 self.nChannels = self.nChannels + 1 #par de canales iguales
205 else:
206 self.nPairs = self.nPairs + 1 #par de canales diferentes
207 self.pairList.append( (self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]) )
208
209 pts2read = self.processingHeaderObj.numHeights * self.processingHeaderObj.profilesPerBlock
210
211 self.pts2read_SelfSpectra = int(self.nChannels * pts2read)
212 self.blocksize = self.pts2read_SelfSpectra
213
214 if self.processingHeaderObj.flag_cspc:
215 self.pts2read_CrossSpectra = int(self.nPairs * pts2read)
216 self.blocksize += self.pts2read_CrossSpectra
217
218 if self.processingHeaderObj.flag_dc:
219 self.pts2read_DCchannels = int(self.systemHeaderObj.numChannels * self.processingHeaderObj.numHeights)
220 self.blocksize += self.pts2read_DCchannels
221
222 # self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
223
224
225 def readBlock(self):
226 """
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
229 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
230 es seteado a 0
231
232 Return: None
233
234 Variables afectadas:
235 self.datablockIndex
236 self.flagIsNewFile
237 self.flagIsNewBlock
238 self.nTotalBlocks
239 self.data_spc
240 self.data_cspc
241 self.data_dc
242
243 Exceptions:
244 Si un bloque leido no es un bloque valido
245 """
246 blockOk_flag = False
247 fpointer = self.fp.tell()
248
249 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
250 spc = spc.reshape( (self.nChannels, self.processingHeaderObj.numHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
251
252 if self.flag_cspc:
253 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
254 cspc = cspc.reshape( (self.nPairs, self.processingHeaderObj.numHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
255
256 if self.processingHeaderObj.flag_dc:
257 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.processingHeaderObj.numHeights*self.systemHeaderObj.numChannels) )
258 dc = dc.reshape( (self.systemHeaderObj.numChannels, self.processingHeaderObj.numHeights) ) #transforma a un arreglo 2D
259
260
261 if not(self.processingHeaderObj.shif_fft):
262 spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
263
264 if self.flag_cspc:
265 cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
266
267
268 spc = numpy.transpose( spc, (0,2,1) )
269 self.data_spc = spc
270
271 if self.flag_cspc:
272 cspc = numpy.transpose( cspc, (0,2,1) )
273 self.data_cspc = cspc['real'] + cspc['imag']*1j
274 else:
275 self.data_cspc = None
276
277 if self.processingHeaderObj.flag_dc:
278 self.data_dc = dc['real'] + dc['imag']*1j
279 else:
280 self.data_dc = None
281
282 self.datablockIndex = 0
283 self.flagIsNewFile = 0
284 self.flagIsNewBlock = 1
285
286 self.nTotalBlocks += 1
287 self.nReadBlocks += 1
288
289 return 1
290
291
292 def getData(self):
293 """
294 Copia el buffer de lectura a la clase "Spectra",
295 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
296 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
297
298 Return:
299 0 : Si no hay mas archivos disponibles
300 1 : Si hizo una buena copia del buffer
301
302 Affected:
303 self.dataOutObj
304 self.datablockIndex
305 self.flagTimeBlock
306 self.flagIsNewBlock
307 """
308
309 if self.flagNoMoreFiles: return 0
310
311 self.flagTimeBlock = 0
312 self.flagIsNewBlock = 0
313
314 if self.__hasNotDataInBuffer():
315
316 if not( self.readNextBlock() ):
317 return 0
318
319 self.updateDataHeader()
320
321 if self.flagNoMoreFiles == 1:
322 print 'Process finished'
323 return 0
324
325 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
326
327 if self.data_dc == None:
328 self.dataOutObj.flagNoData = True
329 return 0
330
331 self.dataOutObj.flagNoData = False
332 self.dataOutObj.flagTimeBlock = self.flagTimeBlock
333
334 self.dataOutObj.data_spc = self.data_spc
335 self.dataOutObj.data_cspc = self.data_cspc
336 self.dataOutObj.data_dc = self.data_dc
337
338 return 1
339
340
341 class SpectraWriter(JRODataWriter):
342
343 """
344 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
345 de los datos siempre se realiza por bloques.
346 """
347
348 dataOutObj = None
349
350 shape_spc_Buffer = None
351 shape_cspc_Buffer = None
352 shape_dc_Buffer = None
353
354 data_spc = None
355 data_cspc = None
356 data_dc = None
357
358
359 def __init__(self, dataOutObj=None):
360 """
361 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
362
363 Affected:
364 self.dataOutObj
365 self.basicHeaderObj
366 self.systemHeaderObj
367 self.radarControllerHeaderObj
368 self.processingHeaderObj
369
370 Return: None
371 """
372 if dataOutObj == None:
373 dataOutObj = Spectra()
374
375 if not( isinstance(dataOutObj, Spectra) ):
376 raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
377
378 self.dataOutObj = dataOutObj
379
380 self.ext = ".pdata"
381
382 self.optchar = "P"
383
384 self.shape_spc_Buffer = None
385 self.shape_cspc_Buffer = None
386 self.shape_dc_Buffer = None
387
388 self.data_spc = None
389 self.data_cspc = None
390 self.data_dc = None
391
392 ####################################
393
394 self.fp = None
395
396 self.nWriteBlocks = 0
397
398 self.flagIsNewFile = 1
399
400 self.nTotalBlocks = 0
401
402 self.flagIsNewBlock = 0
403
404 self.flagNoMoreFiles = 0
405
406 self.setFile = None
407
408 self.dataType = None
409
410 self.path = None
411
412 self.noMoreFiles = 0
413
414 self.filename = None
415
416 self.basicHeaderObj = BasicHeader()
417
418 self.systemHeaderObj = SystemHeader()
419
420 self.radarControllerHeaderObj = RadarControllerHeader()
421
422 self.processingHeaderObj = ProcessingHeader()
423
424
425 def hasAllDataInBuffer(self):
426 return 1
427
428
429 def setBlockDimension(self):
430 """
431 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
432
433 Affected:
434 self.shape_spc_Buffer
435 self.shape_cspc_Buffer
436 self.shape_dc_Buffer
437
438 Return: None
439 """
440 self.shape_spc_Buffer = (self.dataOutObj.nChannels,
441 self.processingHeaderObj.numHeights,
442 self.processingHeaderObj.profilesPerBlock)
443
444 self.shape_cspc_Buffer = (self.dataOutObj.nPairs,
445 self.processingHeaderObj.numHeights,
446 self.processingHeaderObj.profilesPerBlock)
447
448 self.shape_dc_Buffer = (self.systemHeaderObj.numChannels,
449 self.processingHeaderObj.numHeights)
450
451
452 def writeBlock(self):
453 """
454 Escribe el buffer en el file designado
455
456 Affected:
457 self.data_spc
458 self.data_cspc
459 self.data_dc
460 self.flagIsNewFile
461 self.flagIsNewBlock
462 self.nTotalBlocks
463 self.nWriteBlocks
464
465 Return: None
466 """
467
468 spc = numpy.transpose( self.data_spc, (0,2,1) )
469 if not( self.processingHeaderObj.shif_fft ):
470 spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
471 data = spc.reshape((-1))
472 data.tofile(self.fp)
473
474 if self.data_cspc != None:
475 data = numpy.zeros( self.shape_cspc_Buffer, self.dataType )
476 cspc = numpy.transpose( self.data_cspc, (0,2,1) )
477 if not( self.processingHeaderObj.shif_fft ):
478 cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
479 data['real'] = cspc.real
480 data['imag'] = cspc.imag
481 data = data.reshape((-1))
482 data.tofile(self.fp)
483
484 data = numpy.zeros( self.shape_dc_Buffer, self.dataType )
485 dc = self.data_dc
486 data['real'] = dc.real
487 data['imag'] = dc.imag
488 data = data.reshape((-1))
489 data.tofile(self.fp)
490
491 self.data_spc.fill(0)
492 self.data_dc.fill(0)
493 if self.data_cspc != None:
494 self.data_cspc.fill(0)
495
496 self.flagIsNewFile = 0
497 self.flagIsNewBlock = 1
498 self.nTotalBlocks += 1
499 self.nWriteBlocks += 1
500
501
502 def putData(self):
503 """
504 Setea un bloque de datos y luego los escribe en un file
505
506 Affected:
507 self.data_spc
508 self.data_cspc
509 self.data_dc
510
511 Return:
512 0 : Si no hay data o no hay mas files que puedan escribirse
513 1 : Si se escribio la data de un bloque en un file
514 """
515 self.flagIsNewBlock = 0
516
517 if self.dataOutObj.flagNoData:
518 return 0
519
520 if self.dataOutObj.flagTimeBlock:
521 self.data_spc.fill(0)
522 self.data_cspc.fill(0)
523 self.data_dc.fill(0)
524 self.setNextFile()
525
526 self.data_spc = self.dataOutObj.data_spc
527 self.data_cspc = self.dataOutObj.data_cspc
528 self.data_dc = self.dataOutObj.data_dc
529
530 # #self.processingHeaderObj.dataBlocksPerFile)
531 if self.hasAllDataInBuffer():
532 self.getDataHeader()
533 self.writeNextBlock()
534
535 if self.flagNoMoreFiles:
536 #print 'Process finished'
537 return 0
538
539 return 1 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,52 +1,48
1 import os, sys
1 import os, sys
2 import numpy
2 import numpy
3
3
4 path = os.path.split(os.getcwd())[0]
4 path = os.path.split(os.getcwd())[0]
5 sys.path.append(path)
5 sys.path.append(path)
6
6
7 from JROData import JROData
7 from JROData import JROData
8 from IO.JROHeader import SystemHeader, RadarControllerHeader
8 from IO.JROHeader import SystemHeader, RadarControllerHeader
9
9
10 class Voltage(JROData):
10 class Voltage(JROData):
11
11
12 nCohInt = None
12 nCohInt = None
13
13
14 def __init__(self):
14 def __init__(self):
15 '''
15 '''
16 Constructor
16 Constructor
17 '''
17 '''
18
18
19 self.m_RadarControllerHeader = RadarControllerHeader()
19 self.m_RadarControllerHeader = RadarControllerHeader()
20
20
21 self.m_SystemHeader = SystemHeader()
21 self.m_SystemHeader = SystemHeader()
22
22
23 self.type = "Voltage"
23 self.type = "Voltage"
24
24
25 #data es un numpy array de 2 dmensiones ( canales, alturas)
25 #data es un numpy array de 2 dmensiones ( canales, alturas)
26 self.data = None
26 self.data = None
27
27
28 self.dtype = None
28 self.dtype = None
29
29
30 self.nChannels = 0
30 self.nChannels = 0
31
31
32 self.nHeights = 0
32 self.nHeights = 0
33
33
34 self.nProfiles = None
34 self.nProfiles = None
35
35
36 self.heightList = None
36 self.heightList = None
37
37
38 self.channelList = None
38 self.channelList = None
39
39
40 self.channelIndexList = None
40 self.channelIndexList = None
41
41
42 self.flagNoData = True
42 self.flagNoData = True
43
43
44 self.flagTimeBlock = False
44 self.flagTimeBlock = False
45
45
46 self.dataUtcTime = None
46 self.dataUtcTime = None
47
47
48 self.nCohInt = None
48 self.nCohInt = None
49
50
51
52 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,667 +1,727
1 import os, sys
1 import os, sys
2 import glob
2 import glob
3 import time
3 import time
4 import numpy
4 import numpy
5 import fnmatch
5 import fnmatch
6 import time, datetime
6 import time, datetime
7
7
8 path = os.path.split(os.getcwd())[0]
8 path = os.path.split(os.getcwd())[0]
9 sys.path.append(path)
9 sys.path.append(path)
10
10
11 from JROHeader import *
11 from JROHeader import *
12 from Data.JROData import JROData
12 from Data.JROData import JROData
13
13
14 def isNumber(str):
15 """
16 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
17
18 Excepciones:
19 Si un determinado string no puede ser convertido a numero
20 Input:
21 str, string al cual se le analiza para determinar si convertible a un numero o no
22
23 Return:
24 True : si el string es uno numerico
25 False : no es un string numerico
26 """
27 try:
28 float( str )
29 return True
30 except:
31 return False
32
14 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
33 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
15 """
34 """
16 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
35 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
17
36
18 Inputs:
37 Inputs:
19 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
38 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
20
39
21 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
40 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
22 segundos contados desde 01/01/1970.
41 segundos contados desde 01/01/1970.
23 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
42 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
24 segundos contados desde 01/01/1970.
43 segundos contados desde 01/01/1970.
25
44
26 Return:
45 Return:
27 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
46 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
28 fecha especificado, de lo contrario retorna False.
47 fecha especificado, de lo contrario retorna False.
29
48
30 Excepciones:
49 Excepciones:
31 Si el archivo no existe o no puede ser abierto
50 Si el archivo no existe o no puede ser abierto
32 Si la cabecera no puede ser leida.
51 Si la cabecera no puede ser leida.
33
52
34 """
53 """
35 basicHeaderObj = BasicHeader()
54 basicHeaderObj = BasicHeader()
36
55
37 try:
56 try:
38 fp = open(filename,'rb')
57 fp = open(filename,'rb')
39 except:
58 except:
40 raise IOError, "The file %s can't be opened" %(filename)
59 raise IOError, "The file %s can't be opened" %(filename)
41
60
42 sts = basicHeaderObj.read(fp)
61 sts = basicHeaderObj.read(fp)
43 fp.close()
62 fp.close()
44
63
45 if not(sts):
64 if not(sts):
46 print "Skipping the file %s because it has not a valid header" %(filename)
65 print "Skipping the file %s because it has not a valid header" %(filename)
47 return 0
66 return 0
48
67
49 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
68 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
50 return 0
69 return 0
51
70
52 return 1
71 return 1
53
72
54
73
55
74
56
75
57 class JRODataIO:
76 class JRODataIO:
58
77
59 c = 3E8
78 c = 3E8
60
79
61 basicHeaderObj = BasicHeader()
80 basicHeaderObj = BasicHeader()
62
81
63 systemHeaderObj = SystemHeader()
82 systemHeaderObj = SystemHeader()
64
83
65 radarControllerHeaderObj = RadarControllerHeader()
84 radarControllerHeaderObj = RadarControllerHeader()
66
85
67 processingHeaderObj = ProcessingHeader()
86 processingHeaderObj = ProcessingHeader()
68
87
69 online = 0
88 online = 0
70
89
71 dtype = None
90 dtype = None
72
91
73 pathList = []
92 pathList = []
74
93
75 filenameList = []
94 filenameList = []
76
95
77 filename = None
96 filename = None
78
97
79 ext = None
98 ext = None
80
99
81 flagNoMoreFiles = 0
100 flagNoMoreFiles = 0
82
101
83 flagIsNewFile = 1
102 flagIsNewFile = 1
84
103
85 flagTimeBlock = 0
104 flagTimeBlock = 0
86
105
87 flagIsNewBlock = 0
106 flagIsNewBlock = 0
88
107
89 fp = None
108 fp = None
90
109
91 firstHeaderSize = 0
110 firstHeaderSize = 0
92
111
93 basicHeaderSize = 24
112 basicHeaderSize = 24
94
113
95 versionFile = 1103
114 versionFile = 1103
96
115
97 fileSize = None
116 fileSize = None
98
117
99 ippSeconds = None
118 ippSeconds = None
100
119
101 fileSizeByHeader = None
120 fileSizeByHeader = None
102
121
103 fileIndex = None
122 fileIndex = None
104
123
105 profileIndex = None
124 profileIndex = None
106
125
107 blockIndex = None
126 blockIndex = None
108
127
109 nTotalBlocks = None
128 nTotalBlocks = None
110
129
130 maxTimeStep = 30
131
132 lastUTTime = None
133
111 def __init__(self):
134 def __init__(self):
112 pass
135 pass
113
136
114 class JRODataReader(JRODataIO):
137 class JRODataReader(JRODataIO):
115 def __init__(self):
138 def __init__(self):
116 pass
139 pass
117
140
118 def createObjByDefault(self):
141 def createObjByDefault(self):
119 """
142 """
120
143
121 """
144 """
122 raise ValueError, "This method has not been implemented"
145 raise ValueError, "This method has not been implemented"
123
146
124 def getBlockDimension(self):
147 def getBlockDimension(self):
125
148
126 raise ValueError, "No implemented"
149 raise ValueError, "No implemented"
127
150
128 def __searchFilesOffLine(self,
151 def __searchFilesOffLine(self,
129 path,
152 path,
130 startDate,
153 startDate,
131 endDate,
154 endDate,
132 startTime=datetime.time(0,0,0),
155 startTime=datetime.time(0,0,0),
133 endTime=datetime.time(23,59,59),
156 endTime=datetime.time(23,59,59),
134 set=None,
157 set=None,
135 expLabel="",
158 expLabel="",
136 ext=".r"):
159 ext=".r"):
137 dirList = []
160 dirList = []
138 for thisPath in os.listdir(path):
161 for thisPath in os.listdir(path):
139 if os.path.isdir(os.path.join(path,thisPath)):
162 if os.path.isdir(os.path.join(path,thisPath)):
140 dirList.append(thisPath)
163 dirList.append(thisPath)
141
164
142 if not(dirList):
165 if not(dirList):
143 return None, None
166 return None, None
144
167
145 pathList = []
168 pathList = []
146 dateList = []
169 dateList = []
147
170
148 thisDate = startDate
171 thisDate = startDate
149
172
150 while(thisDate <= endDate):
173 while(thisDate <= endDate):
151 year = thisDate.timetuple().tm_year
174 year = thisDate.timetuple().tm_year
152 doy = thisDate.timetuple().tm_yday
175 doy = thisDate.timetuple().tm_yday
153
176
154 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
177 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
155 if len(match) == 0:
178 if len(match) == 0:
156 thisDate += datetime.timedelta(1)
179 thisDate += datetime.timedelta(1)
157 continue
180 continue
158
181
159 pathList.append(os.path.join(path,match[0],expLabel))
182 pathList.append(os.path.join(path,match[0],expLabel))
160 dateList.append(thisDate)
183 dateList.append(thisDate)
161 thisDate += datetime.timedelta(1)
184 thisDate += datetime.timedelta(1)
162
185
163 filenameList = []
186 filenameList = []
164 for index in range(len(pathList)):
187 for index in range(len(pathList)):
165
188
166 thisPath = pathList[index]
189 thisPath = pathList[index]
167 fileList = glob.glob1(thisPath, "*%s" %ext)
190 fileList = glob.glob1(thisPath, "*%s" %ext)
168 fileList.sort()
191 fileList.sort()
169
192
170 #Busqueda de datos en el rango de horas indicados
193 #Busqueda de datos en el rango de horas indicados
171 thisDate = dateList[index]
194 thisDate = dateList[index]
172 startDT = datetime.datetime.combine(thisDate, startTime)
195 startDT = datetime.datetime.combine(thisDate, startTime)
173 endDT = datetime.datetime.combine(thisDate, endTime)
196 endDT = datetime.datetime.combine(thisDate, endTime)
174
197
175 startUtSeconds = time.mktime(startDT.timetuple())
198 startUtSeconds = time.mktime(startDT.timetuple())
176 endUtSeconds = time.mktime(endDT.timetuple())
199 endUtSeconds = time.mktime(endDT.timetuple())
177
200
178 for file in fileList:
201 for file in fileList:
179
202
180 filename = os.path.join(thisPath,file)
203 filename = os.path.join(thisPath,file)
181
204
182 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
205 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
183 filenameList.append(filename)
206 filenameList.append(filename)
184
207
185 if not(filenameList):
208 if not(filenameList):
186 return None, None
209 return None, None
187
210
188 self.filenameList = filenameList
211 self.filenameList = filenameList
189
212
190 return pathList, filenameList
213 return pathList, filenameList
191
214
192 def setup(self,dataOutObj=None,
215 def setup(self,dataOutObj=None,
193 path=None,startDate=None,
216 path=None,startDate=None,
194 endDate=None,
217 endDate=None,
195 startTime=datetime.time(0,0,0),
218 startTime=datetime.time(0,0,0),
196 endTime=datetime.time(23,59,59),
219 endTime=datetime.time(23,59,59),
197 set=0,
220 set=0,
198 expLabel = "",
221 expLabel = "",
199 ext = None,
222 ext = None,
200 online = 0):
223 online = 0):
201
224
202 if path == None:
225 if path == None:
203 raise ValueError, "The path is not valid"
226 raise ValueError, "The path is not valid"
204
227
205 if ext == None:
228 if ext == None:
206 ext = self.ext
229 ext = self.ext
207
230
208 if dataOutObj == None:
231 if dataOutObj == None:
209 dataOutObj = self.createObjByDefault()
232 dataOutObj = self.createObjByDefault()
210
233
211 self.dataOutObj = dataOutObj
234 self.dataOutObj = dataOutObj
212
235
213 if online:
236 if online:
214 pass
237 pass
215
238
216 else:
239 else:
217 print "Searching file in offline mode"
240 print "Searching file in offline mode"
218 pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
241 pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
219 if not(pathList):
242 if not(pathList):
220 print "No files in range: %s - %s"%(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
243 print "No files in range: %s - %s"%(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
221 return None
244 return None
222 self.fileIndex = -1
245 self.fileIndex = -1
223 self.pathList = pathList
246 self.pathList = pathList
224 self.filenameList = filenameList
247 self.filenameList = filenameList
225
248
226 self.online = online
249 self.online = online
227 ext = ext.lower()
250 ext = ext.lower()
228 self.ext = ext
251 self.ext = ext
229
252
230 if not(self.setNextFile()):
253 if not(self.setNextFile()):
231 if (startDate!=None) and (endDate!=None):
254 if (startDate!=None) and (endDate!=None):
232 print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
255 print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
233 elif startDate != None:
256 elif startDate != None:
234 print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
257 print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
235 else:
258 else:
236 print "No files"
259 print "No files"
237
260
238 return None
261 return None
239
262
240 self.updateDataHeader()
263 # self.updateDataHeader()
241
264
242 return self.dataOutObj
265 return self.dataOutObj
243
266
244 def __setNextFileOffline(self):
267 def __setNextFileOffline(self):
245 idFile = self.fileIndex
268 idFile = self.fileIndex
246
269
247 while (True):
270 while (True):
248 idFile += 1
271 idFile += 1
249 if not(idFile < len(self.filenameList)):
272 if not(idFile < len(self.filenameList)):
250 self.flagNoMoreFiles = 1
273 self.flagNoMoreFiles = 1
251 print "No more Files"
274 print "No more Files"
252 return 0
275 return 0
253
276
254 filename = self.filenameList[idFile]
277 filename = self.filenameList[idFile]
255
278
256 if not(self.__verifyFile(filename)):
279 if not(self.__verifyFile(filename)):
257 continue
280 continue
258
281
259 fileSize = os.path.getsize(filename)
282 fileSize = os.path.getsize(filename)
260 fp = open(filename,'rb')
283 fp = open(filename,'rb')
261 break
284 break
262
285
263 self.flagIsNewFile = 1
286 self.flagIsNewFile = 1
264 self.fileIndex = idFile
287 self.fileIndex = idFile
265 self.filename = filename
288 self.filename = filename
266 self.fileSize = fileSize
289 self.fileSize = fileSize
267 self.fp = fp
290 self.fp = fp
268
291
269 print "Setting the file: %s"%self.filename
292 print "Setting the file: %s"%self.filename
270
293
271 return 1
294 return 1
272
295
273
296
274
297
275 def setNextFile(self):
298 def setNextFile(self):
276 if self.fp != None:
299 if self.fp != None:
277 self.fp.close()
300 self.fp.close()
278
301
279 if self.online:
302 if self.online:
280 newFile = self.__setNextFileOnline()
303 newFile = self.__setNextFileOnline()
281 else:
304 else:
282 newFile = self.__setNextFileOffline()
305 newFile = self.__setNextFileOffline()
283
306
284 if not(newFile):
307 if not(newFile):
285 return 0
308 return 0
286
309
287 self.__readFirstHeader()
310 self.__readFirstHeader()
288 self.nReadBlocks = 0
311 self.nReadBlocks = 0
289 return 1
312 return 1
290
313
314 def __setNewBlock(self):
315 if self.fp == None:
316 return 0
317
318 if self.flagIsNewFile:
319 return 1
320
321 self.lastUTTime = self.basicHeaderObj.utc
322 currentSize = self.fileSize - self.fp.tell()
323 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
324
325 if (currentSize >= neededSize):
326 self.__rdBasicHeader()
327 return 1
328
329 if not(self.setNextFile()):
330 return 0
331
332 deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
333
334 self.flagTimeBlock = 0
335
336 if deltaTime > self.maxTimeStep:
337 self.flagTimeBlock = 1
338
339 return 1
340
341
342 def readNextBlock(self):
343 if not(self.__setNewBlock()):
344 return 0
345
346 if not(self.readBlock()):
347 return 0
348
349 return 1
350
291 def __rdProcessingHeader(self, fp=None):
351 def __rdProcessingHeader(self, fp=None):
292 if fp == None:
352 if fp == None:
293 fp = self.fp
353 fp = self.fp
294
354
295 self.processingHeaderObj.read(fp)
355 self.processingHeaderObj.read(fp)
296
356
297 def __rdRadarControllerHeader(self, fp=None):
357 def __rdRadarControllerHeader(self, fp=None):
298 if fp == None:
358 if fp == None:
299 fp = self.fp
359 fp = self.fp
300
360
301 self.radarControllerHeaderObj.read(fp)
361 self.radarControllerHeaderObj.read(fp)
302
362
303 def __rdSystemHeader(self, fp=None):
363 def __rdSystemHeader(self, fp=None):
304 if fp == None:
364 if fp == None:
305 fp = self.fp
365 fp = self.fp
306
366
307 self.systemHeaderObj.read(fp)
367 self.systemHeaderObj.read(fp)
308
368
309 def __rdBasicHeader(self, fp=None):
369 def __rdBasicHeader(self, fp=None):
310 if fp == None:
370 if fp == None:
311 fp = self.fp
371 fp = self.fp
312
372
313 self.basicHeaderObj.read(fp)
373 self.basicHeaderObj.read(fp)
314
374
315
375
316 def __readFirstHeader(self):
376 def __readFirstHeader(self):
317 self.__rdBasicHeader()
377 self.__rdBasicHeader()
318 self.__rdSystemHeader()
378 self.__rdSystemHeader()
319 self.__rdRadarControllerHeader()
379 self.__rdRadarControllerHeader()
320 self.__rdProcessingHeader()
380 self.__rdProcessingHeader()
321
381
322 self.firstHeaderSize = self.basicHeaderObj.size
382 self.firstHeaderSize = self.basicHeaderObj.size
323
383
324 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
384 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
325 if datatype == 0:
385 if datatype == 0:
326 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
386 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
327 elif datatype == 1:
387 elif datatype == 1:
328 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
388 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
329 elif datatype == 2:
389 elif datatype == 2:
330 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
390 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
331 elif datatype == 3:
391 elif datatype == 3:
332 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
392 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
333 elif datatype == 4:
393 elif datatype == 4:
334 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
394 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
335 elif datatype == 5:
395 elif datatype == 5:
336 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
396 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
337 else:
397 else:
338 raise ValueError, 'Data type was not defined'
398 raise ValueError, 'Data type was not defined'
339
399
340 self.dtype = datatype_str
400 self.dtype = datatype_str
341 self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
401 self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
342 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
402 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
343 # self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
403 # self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
344 # self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
404 # self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
345 self.getBlockDimension()
405 self.getBlockDimension()
346
406
347
407
348 def __verifyFile(self, filename, msgFlag=True):
408 def __verifyFile(self, filename, msgFlag=True):
349 msg = None
409 msg = None
350 try:
410 try:
351 fp = open(filename, 'rb')
411 fp = open(filename, 'rb')
352 currentPosition = fp.tell()
412 currentPosition = fp.tell()
353 except:
413 except:
354 if msgFlag:
414 if msgFlag:
355 print "The file %s can't be opened" % (filename)
415 print "The file %s can't be opened" % (filename)
356 return False
416 return False
357
417
358 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
418 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
359
419
360 if neededSize == 0:
420 if neededSize == 0:
361 basicHeaderObj = BasicHeader()
421 basicHeaderObj = BasicHeader()
362 systemHeaderObj = SystemHeader()
422 systemHeaderObj = SystemHeader()
363 radarControllerHeaderObj = RadarControllerHeader()
423 radarControllerHeaderObj = RadarControllerHeader()
364 processingHeaderObj = ProcessingHeader()
424 processingHeaderObj = ProcessingHeader()
365
425
366 try:
426 try:
367 if not( basicHeaderObj.read(fp) ): raise ValueError
427 if not( basicHeaderObj.read(fp) ): raise ValueError
368 if not( systemHeaderObj.read(fp) ): raise ValueError
428 if not( systemHeaderObj.read(fp) ): raise ValueError
369 if not( radarControllerHeaderObj.read(fp) ): raise ValueError
429 if not( radarControllerHeaderObj.read(fp) ): raise ValueError
370 if not( processingHeaderObj.read(fp) ): raise ValueError
430 if not( processingHeaderObj.read(fp) ): raise ValueError
371 data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
431 data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
372
432
373 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
433 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
374
434
375 except:
435 except:
376 if msgFlag:
436 if msgFlag:
377 print "\tThe file %s is empty or it hasn't enough data" % filename
437 print "\tThe file %s is empty or it hasn't enough data" % filename
378
438
379 fp.close()
439 fp.close()
380 return False
440 return False
381 else:
441 else:
382 msg = "\tSkipping the file %s due to it hasn't enough data" %filename
442 msg = "\tSkipping the file %s due to it hasn't enough data" %filename
383
443
384 fp.close()
444 fp.close()
385 fileSize = os.path.getsize(filename)
445 fileSize = os.path.getsize(filename)
386 currentSize = fileSize - currentPosition
446 currentSize = fileSize - currentPosition
387 if currentSize < neededSize:
447 if currentSize < neededSize:
388 if msgFlag and (msg != None):
448 if msgFlag and (msg != None):
389 print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
449 print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
390 return False
450 return False
391
451
392 return True
452 return True
393
453
394 class JRODataWriter(JRODataIO):
454 class JRODataWriter(JRODataIO):
395
455
396 """
456 """
397 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
457 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
398 de los datos siempre se realiza por bloques.
458 de los datos siempre se realiza por bloques.
399 """
459 """
400
460
401 blockIndex = 0
461 blockIndex = 0
402
462
403 setFile = None
463 setFile = None
404
464
405
465
406 def __init__(self, dataOutObj=None):
466 def __init__(self, dataOutObj=None):
407 raise ValueError, "Not implemented"
467 raise ValueError, "Not implemented"
408
468
409
469
410 def hasAllDataInBuffer(self):
470 def hasAllDataInBuffer(self):
411 raise ValueError, "Not implemented"
471 raise ValueError, "Not implemented"
412
472
413
473
414 def setBlockDimension(self):
474 def setBlockDimension(self):
415 raise ValueError, "Not implemented"
475 raise ValueError, "Not implemented"
416
476
417
477
418 def writeBlock(self):
478 def writeBlock(self):
419 raise ValueError, "No implemented"
479 raise ValueError, "No implemented"
420
480
421
481
422 def putData(self):
482 def putData(self):
423 raise ValueError, "No implemented"
483 raise ValueError, "No implemented"
424
484
425
485
426 def __writeFirstHeader(self):
486 def __writeFirstHeader(self):
427 """
487 """
428 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
488 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
429
489
430 Affected:
490 Affected:
431 __dataType
491 __dataType
432
492
433 Return:
493 Return:
434 None
494 None
435 """
495 """
436
496
437 # CALCULAR PARAMETROS
497 # CALCULAR PARAMETROS
438
498
439 sizeLongHeader = 0#XXXX
499 sizeLongHeader = 0#XXXX
440 self.basicHeaderObj.size = 24 + sizeLongHeader
500 self.basicHeaderObj.size = 24 + sizeLongHeader
441
501
442 self.__writeBasicHeader()
502 self.__writeBasicHeader()
443 self.__wrSystemHeader()
503 self.__wrSystemHeader()
444 self.__wrRadarControllerHeader()
504 self.__wrRadarControllerHeader()
445 self.__wrProcessingHeader()
505 self.__wrProcessingHeader()
446 self.dtype = self.dataOutObj.dtype
506 self.dtype = self.dataOutObj.dtype
447
507
448
508
449 def __writeBasicHeader(self, fp=None):
509 def __writeBasicHeader(self, fp=None):
450 """
510 """
451 Escribe solo el Basic header en el file creado
511 Escribe solo el Basic header en el file creado
452
512
453 Return:
513 Return:
454 None
514 None
455 """
515 """
456 if fp == None:
516 if fp == None:
457 fp = self.fp
517 fp = self.fp
458
518
459 self.dataOutObj.basicHeaderObj.write(fp)
519 self.dataOutObj.basicHeaderObj.write(fp)
460
520
461
521
462 def __wrSystemHeader(self, fp=None):
522 def __wrSystemHeader(self, fp=None):
463 """
523 """
464 Escribe solo el System header en el file creado
524 Escribe solo el System header en el file creado
465
525
466 Return:
526 Return:
467 None
527 None
468 """
528 """
469 if fp == None:
529 if fp == None:
470 fp = self.fp
530 fp = self.fp
471
531
472 self.dataOutObj.systemHeaderObj.write(fp)
532 self.dataOutObj.systemHeaderObj.write(fp)
473
533
474
534
475 def __wrRadarControllerHeader(self, fp=None):
535 def __wrRadarControllerHeader(self, fp=None):
476 """
536 """
477 Escribe solo el RadarController header en el file creado
537 Escribe solo el RadarController header en el file creado
478
538
479 Return:
539 Return:
480 None
540 None
481 """
541 """
482 if fp == None:
542 if fp == None:
483 fp = self.fp
543 fp = self.fp
484
544
485 self.dataOutObj.radarControllerHeaderObj.write(fp)
545 self.dataOutObj.radarControllerHeaderObj.write(fp)
486
546
487
547
488 def __wrProcessingHeader(self, fp=None):
548 def __wrProcessingHeader(self, fp=None):
489 """
549 """
490 Escribe solo el Processing header en el file creado
550 Escribe solo el Processing header en el file creado
491
551
492 Return:
552 Return:
493 None
553 None
494 """
554 """
495 if fp == None:
555 if fp == None:
496 fp = self.fp
556 fp = self.fp
497
557
498 self.dataOutObj.processingHeaderObj.write(fp)
558 self.dataOutObj.processingHeaderObj.write(fp)
499
559
500
560
501 def setNextFile(self):
561 def setNextFile(self):
502 """
562 """
503 Determina el siguiente file que sera escrito
563 Determina el siguiente file que sera escrito
504
564
505 Affected:
565 Affected:
506 self.filename
566 self.filename
507 self.subfolder
567 self.subfolder
508 self.fp
568 self.fp
509 self.setFile
569 self.setFile
510 self.flagIsNewFile
570 self.flagIsNewFile
511
571
512 Return:
572 Return:
513 0 : Si el archivo no puede ser escrito
573 0 : Si el archivo no puede ser escrito
514 1 : Si el archivo esta listo para ser escrito
574 1 : Si el archivo esta listo para ser escrito
515 """
575 """
516 ext = self.ext
576 ext = self.ext
517 path = self.path
577 path = self.path
518
578
519 if self.fp != None:
579 if self.fp != None:
520 self.fp.close()
580 self.fp.close()
521
581
522 timeTuple = time.localtime( self.dataOutObj.dataUtcTime)
582 timeTuple = time.localtime( self.dataOutObj.dataUtcTime)
523 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
583 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
524
584
525 doypath = os.path.join( path, subfolder )
585 doypath = os.path.join( path, subfolder )
526 if not( os.path.exists(doypath) ):
586 if not( os.path.exists(doypath) ):
527 os.mkdir(doypath)
587 os.mkdir(doypath)
528 self.setFile = -1 #inicializo mi contador de seteo
588 self.setFile = -1 #inicializo mi contador de seteo
529 else:
589 else:
530 filesList = os.listdir( doypath )
590 filesList = os.listdir( doypath )
531 if len( filesList ) > 0:
591 if len( filesList ) > 0:
532 filesList = sorted( filesList, key=str.lower )
592 filesList = sorted( filesList, key=str.lower )
533 filen = filesList[-1]
593 filen = filesList[-1]
534 # el filename debera tener el siguiente formato
594 # el filename debera tener el siguiente formato
535 # 0 1234 567 89A BCDE (hex)
595 # 0 1234 567 89A BCDE (hex)
536 # x YYYY DDD SSS .ext
596 # x YYYY DDD SSS .ext
537 if isNumber( filen[8:11] ):
597 if isNumber( filen[8:11] ):
538 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
598 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
539 else:
599 else:
540 self.setFile = -1
600 self.setFile = -1
541 else:
601 else:
542 self.setFile = -1 #inicializo mi contador de seteo
602 self.setFile = -1 #inicializo mi contador de seteo
543
603
544 setFile = self.setFile
604 setFile = self.setFile
545 setFile += 1
605 setFile += 1
546
606
547 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
607 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
548 timeTuple.tm_year,
608 timeTuple.tm_year,
549 timeTuple.tm_yday,
609 timeTuple.tm_yday,
550 setFile,
610 setFile,
551 ext )
611 ext )
552
612
553 filename = os.path.join( path, subfolder, file )
613 filename = os.path.join( path, subfolder, file )
554
614
555 fp = open( filename,'wb' )
615 fp = open( filename,'wb' )
556
616
557 self.blockIndex = 0
617 self.blockIndex = 0
558
618
559 #guardando atributos
619 #guardando atributos
560 self.filename = filename
620 self.filename = filename
561 self.subfolder = subfolder
621 self.subfolder = subfolder
562 self.fp = fp
622 self.fp = fp
563 self.setFile = setFile
623 self.setFile = setFile
564 self.flagIsNewFile = 1
624 self.flagIsNewFile = 1
565
625
566 print 'Writing the file: %s'%self.filename
626 print 'Writing the file: %s'%self.filename
567
627
568 self.__writeFirstHeader()
628 self.__writeFirstHeader()
569
629
570 return 1
630 return 1
571
631
572
632
573 def __setNewBlock(self):
633 def __setNewBlock(self):
574 """
634 """
575 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
635 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
576
636
577 Return:
637 Return:
578 0 : si no pudo escribir nada
638 0 : si no pudo escribir nada
579 1 : Si escribio el Basic el First Header
639 1 : Si escribio el Basic el First Header
580 """
640 """
581 if self.fp == None:
641 if self.fp == None:
582 self.setNextFile()
642 self.setNextFile()
583
643
584 if self.flagIsNewFile:
644 if self.flagIsNewFile:
585 return 1
645 return 1
586
646
587 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
647 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
588 self.__writeBasicHeader()
648 self.__writeBasicHeader()
589 return 1
649 return 1
590
650
591 if not( self.setNextFile() ):
651 if not( self.setNextFile() ):
592 return 0
652 return 0
593
653
594 return 1
654 return 1
595
655
596
656
597 def writeNextBlock(self):
657 def writeNextBlock(self):
598 """
658 """
599 Selecciona el bloque siguiente de datos y los escribe en un file
659 Selecciona el bloque siguiente de datos y los escribe en un file
600
660
601 Return:
661 Return:
602 0 : Si no hizo pudo escribir el bloque de datos
662 0 : Si no hizo pudo escribir el bloque de datos
603 1 : Si no pudo escribir el bloque de datos
663 1 : Si no pudo escribir el bloque de datos
604 """
664 """
605 if not( self.__setNewBlock() ):
665 if not( self.__setNewBlock() ):
606 return 0
666 return 0
607
667
608 self.writeBlock()
668 self.writeBlock()
609
669
610 return 1
670 return 1
611
671
612
672
613 def getDataHeader(self):
673 def getDataHeader(self):
614 """
674 """
615 Obtiene una copia del First Header
675 Obtiene una copia del First Header
616
676
617 Affected:
677 Affected:
618 self.basicHeaderObj
678 self.basicHeaderObj
619 self.systemHeaderObj
679 self.systemHeaderObj
620 self.radarControllerHeaderObj
680 self.radarControllerHeaderObj
621 self.processingHeaderObj
681 self.processingHeaderObj
622 self.dtype
682 self.dtype
623
683
624 Return:
684 Return:
625 None
685 None
626 """
686 """
627
687
628 raise ValueError, "No implemented"
688 raise ValueError, "No implemented"
629
689
630 def setup(self, path, set=0, ext=None):
690 def setup(self, path, set=0, ext=None):
631 """
691 """
632 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
692 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
633
693
634 Inputs:
694 Inputs:
635 path : el path destino en el cual se escribiran los files a crear
695 path : el path destino en el cual se escribiran los files a crear
636 format : formato en el cual sera salvado un file
696 format : formato en el cual sera salvado un file
637 set : el setebo del file
697 set : el setebo del file
638
698
639 Return:
699 Return:
640 0 : Si no realizo un buen seteo
700 0 : Si no realizo un buen seteo
641 1 : Si realizo un buen seteo
701 1 : Si realizo un buen seteo
642 """
702 """
643
703
644 if ext == None:
704 if ext == None:
645 ext = self.ext
705 ext = self.ext
646
706
647 ext = ext.lower()
707 ext = ext.lower()
648
708
649 self.path = path
709 self.path = path
650 self.setFile = set - 1
710 self.setFile = set - 1
651 self.ext = ext
711 self.ext = ext
652 #self.format = format
712 #self.format = format
653 self.getDataHeader()
713 self.getDataHeader()
654
714
655 self.setBlockDimension()
715 self.setBlockDimension()
656
716
657 if not( self.setNextFile() ):
717 if not( self.setNextFile() ):
658 print "There isn't a next file"
718 print "There isn't a next file"
659 return 0
719 return 0
660
720
661 return 1
721 return 1
662
722
663
723
664
724
665
725
666
726
667
727
Show file before | Show file after | Hide comments
@@ -1,506 +1,506
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author $Author: vsarmiento $
4 @author $Author: vsarmiento $
5 @version $Id: HeaderIO.py 37 2012-03-26 22:55:13Z vsarmiento $
5 @version $Id: HeaderIO.py 37 2012-03-26 22:55:13Z vsarmiento $
6 '''
6 '''
7
7
8 import numpy
8 import numpy
9 import copy
9 import copy
10
10
11 class Header:
11 class Header:
12
12
13 def __init__(self):
13 def __init__(self):
14 raise
14 raise
15
15
16 def copy(self):
16 def copy(self):
17 return copy.deepcopy(self)
17 return copy.deepcopy(self)
18
18
19 def read():
19 def read():
20 pass
20 pass
21
21
22 def write():
22 def write():
23 pass
23 pass
24
24
25 class BasicHeader(Header):
25 class BasicHeader(Header):
26
26
27 size = None
27 size = None
28 version = None
28 version = None
29 dataBlock = None
29 dataBlock = None
30 utc = None
30 utc = None
31 miliSecond = None
31 miliSecond = None
32 timeZone = None
32 timeZone = None
33 dstFlag = None
33 dstFlag = None
34 errorCount = None
34 errorCount = None
35 struct = None
35 struct = None
36
36
37 def __init__(self):
37 def __init__(self):
38
38
39 self.size = 0
39 self.size = 0
40 self.version = 0
40 self.version = 0
41 self.dataBlock = 0
41 self.dataBlock = 0
42 self.utc = 0
42 self.utc = 0
43 self.miliSecond = 0
43 self.miliSecond = 0
44 self.timeZone = 0
44 self.timeZone = 0
45 self.dstFlag = 0
45 self.dstFlag = 0
46 self.errorCount = 0
46 self.errorCount = 0
47 self.struct = numpy.dtype([
47 self.struct = numpy.dtype([
48 ('nSize','<u4'),
48 ('nSize','<u4'),
49 ('nVersion','<u2'),
49 ('nVersion','<u2'),
50 ('nDataBlockId','<u4'),
50 ('nDataBlockId','<u4'),
51 ('nUtime','<u4'),
51 ('nUtime','<u4'),
52 ('nMilsec','<u2'),
52 ('nMilsec','<u2'),
53 ('nTimezone','<i2'),
53 ('nTimezone','<i2'),
54 ('nDstflag','<i2'),
54 ('nDstflag','<i2'),
55 ('nErrorCount','<u4')
55 ('nErrorCount','<u4')
56 ])
56 ])
57
57
58
58
59 def read(self, fp):
59 def read(self, fp):
60 try:
60 try:
61 header = numpy.fromfile(fp, self.struct,1)
61 header = numpy.fromfile(fp, self.struct,1)
62 self.size = header['nSize'][0]
62 self.size = header['nSize'][0]
63 self.version = header['nVersion'][0]
63 self.version = header['nVersion'][0]
64 self.dataBlock = header['nDataBlockId'][0]
64 self.dataBlock = header['nDataBlockId'][0]
65 self.utc = header['nUtime'][0]
65 self.utc = header['nUtime'][0]
66 self.miliSecond = header['nMilsec'][0]
66 self.miliSecond = header['nMilsec'][0]
67 self.timeZone = header['nTimezone'][0]
67 self.timeZone = header['nTimezone'][0]
68 self.dstFlag = header['nDstflag'][0]
68 self.dstFlag = header['nDstflag'][0]
69 self.errorCount = header['nErrorCount'][0]
69 self.errorCount = header['nErrorCount'][0]
70 except:
70 except:
71 return 0
71 return 0
72
72
73 return 1
73 return 1
74
74
75 def write(self, fp):
75 def write(self, fp):
76 headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
76 headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
77 header = numpy.array(headerTuple,self.struct)
77 header = numpy.array(headerTuple,self.struct)
78 header.tofile(fp)
78 header.tofile(fp)
79
79
80 return 1
80 return 1
81
81
82 class SystemHeader(Header):
82 class SystemHeader(Header):
83
83
84 size = None
84 size = None
85 nSamples = None
85 nSamples = None
86 nProfiles = None
86 nProfiles = None
87 nChannels = None
87 nChannels = None
88 adcResolution = None
88 adcResolution = None
89 pciDioBusWidth = None
89 pciDioBusWidth = None
90 struct = None
90 struct = None
91
91
92 def __init__(self):
92 def __init__(self):
93 self.size = 0
93 self.size = 0
94 self.nSamples = 0
94 self.nSamples = 0
95 self.nProfiles = 0
95 self.nProfiles = 0
96 self.nChannels = 0
96 self.nChannels = 0
97 self.adcResolution = 0
97 self.adcResolution = 0
98 self.pciDioBusWidth = 0
98 self.pciDioBusWidth = 0
99 self.struct = numpy.dtype([
99 self.struct = numpy.dtype([
100 ('nSize','<u4'),
100 ('nSize','<u4'),
101 ('nNumSamples','<u4'),
101 ('nNumSamples','<u4'),
102 ('nNumProfiles','<u4'),
102 ('nNumProfiles','<u4'),
103 ('nNumChannels','<u4'),
103 ('nNumChannels','<u4'),
104 ('nADCResolution','<u4'),
104 ('nADCResolution','<u4'),
105 ('nPCDIOBusWidth','<u4'),
105 ('nPCDIOBusWidth','<u4'),
106 ])
106 ])
107
107
108
108
109 def read(self, fp):
109 def read(self, fp):
110 try:
110 try:
111 header = numpy.fromfile(fp,self.struct,1)
111 header = numpy.fromfile(fp,self.struct,1)
112 self.size = header['nSize'][0]
112 self.size = header['nSize'][0]
113 self.nSamples = header['nNumSamples'][0]
113 self.nSamples = header['nNumSamples'][0]
114 self.nProfiles = header['nNumProfiles'][0]
114 self.nProfiles = header['nNumProfiles'][0]
115 self.nChannels = header['nNumChannels'][0]
115 self.nChannels = header['nNumChannels'][0]
116 self.adcResolution = header['nADCResolution'][0]
116 self.adcResolution = header['nADCResolution'][0]
117 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
117 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
118 except:
118 except:
119 return 0
119 return 0
120
120
121 return 1
121 return 1
122
122
123 def write(self, fp):
123 def write(self, fp):
124 headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
124 headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
125 header = numpy.array(headerTuple,self.struct)
125 header = numpy.array(headerTuple,self.struct)
126 header.tofile(fp)
126 header.tofile(fp)
127
127
128 return 1
128 return 1
129
129
130 class RadarControllerHeader(Header):
130 class RadarControllerHeader(Header):
131
131
132 size = None
132 size = None
133 expType = None
133 expType = None
134 nTx = None
134 nTx = None
135 ipp = None
135 ipp = None
136 txA = None
136 txA = None
137 txB = None
137 txB = None
138 nWindows = None
138 nWindows = None
139 numTaus = None
139 numTaus = None
140 codeType = None
140 codeType = None
141 line6Function = None
141 line6Function = None
142 line5Function = None
142 line5Function = None
143 fClock = None
143 fClock = None
144 prePulseBefore = None
144 prePulseBefore = None
145 prePulserAfter = None
145 prePulserAfter = None
146 rangeIpp = None
146 rangeIpp = None
147 rangeTxA = None
147 rangeTxA = None
148 rangeTxB = None
148 rangeTxB = None
149 struct = None
149 struct = None
150
150
151 def __init__(self):
151 def __init__(self):
152 self.size = 0
152 self.size = 0
153 self.expType = 0
153 self.expType = 0
154 self.nTx = 0
154 self.nTx = 0
155 self.ipp = 0
155 self.ipp = 0
156 self.txA = 0
156 self.txA = 0
157 self.txB = 0
157 self.txB = 0
158 self.nWindows = 0
158 self.nWindows = 0
159 self.numTaus = 0
159 self.numTaus = 0
160 self.codeType = 0
160 self.codeType = 0
161 self.line6Function = 0
161 self.line6Function = 0
162 self.line5Function = 0
162 self.line5Function = 0
163 self.fClock = 0
163 self.fClock = 0
164 self.prePulseBefore = 0
164 self.prePulseBefore = 0
165 self.prePulserAfter = 0
165 self.prePulserAfter = 0
166 self.rangeIpp = 0
166 self.rangeIpp = 0
167 self.rangeTxA = 0
167 self.rangeTxA = 0
168 self.rangeTxB = 0
168 self.rangeTxB = 0
169 self.struct = numpy.dtype([
169 self.struct = numpy.dtype([
170 ('nSize','<u4'),
170 ('nSize','<u4'),
171 ('nExpType','<u4'),
171 ('nExpType','<u4'),
172 ('nNTx','<u4'),
172 ('nNTx','<u4'),
173 ('fIpp','<f4'),
173 ('fIpp','<f4'),
174 ('fTxA','<f4'),
174 ('fTxA','<f4'),
175 ('fTxB','<f4'),
175 ('fTxB','<f4'),
176 ('nNumWindows','<u4'),
176 ('nNumWindows','<u4'),
177 ('nNumTaus','<u4'),
177 ('nNumTaus','<u4'),
178 ('nCodeType','<u4'),
178 ('nCodeType','<u4'),
179 ('nLine6Function','<u4'),
179 ('nLine6Function','<u4'),
180 ('nLine5Function','<u4'),
180 ('nLine5Function','<u4'),
181 ('fClock','<f4'),
181 ('fClock','<f4'),
182 ('nPrePulseBefore','<u4'),
182 ('nPrePulseBefore','<u4'),
183 ('nPrePulseAfter','<u4'),
183 ('nPrePulseAfter','<u4'),
184 ('sRangeIPP','<a20'),
184 ('sRangeIPP','<a20'),
185 ('sRangeTxA','<a20'),
185 ('sRangeTxA','<a20'),
186 ('sRangeTxB','<a20'),
186 ('sRangeTxB','<a20'),
187 ])
187 ])
188
188
189 self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
189 self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
190
190
191 self.samplingWindow = None
191 self.samplingWindow = None
192 self.numHeights = None
192 self.nHeights = None
193 self.firstHeight = None
193 self.firstHeight = None
194 self.deltaHeight = None
194 self.deltaHeight = None
195 self.samplesWin = None
195 self.samplesWin = None
196
196
197 self.numCode = None
197 self.numCode = None
198 self.numBaud = None
198 self.numBaud = None
199 self.code = None
199 self.code = None
200 self.flip1 = None
200 self.flip1 = None
201 self.flip2 = None
201 self.flip2 = None
202
202
203 self.dynamic = numpy.array([],numpy.dtype('byte'))
203 self.dynamic = numpy.array([],numpy.dtype('byte'))
204
204
205
205
206 def read(self, fp):
206 def read(self, fp):
207 try:
207 try:
208 startFp = fp.tell()
208 startFp = fp.tell()
209 header = numpy.fromfile(fp,self.struct,1)
209 header = numpy.fromfile(fp,self.struct,1)
210 self.size = header['nSize'][0]
210 self.size = header['nSize'][0]
211 self.expType = header['nExpType'][0]
211 self.expType = header['nExpType'][0]
212 self.nTx = header['nNTx'][0]
212 self.nTx = header['nNTx'][0]
213 self.ipp = header['fIpp'][0]
213 self.ipp = header['fIpp'][0]
214 self.txA = header['fTxA'][0]
214 self.txA = header['fTxA'][0]
215 self.txB = header['fTxB'][0]
215 self.txB = header['fTxB'][0]
216 self.nWindows = header['nNumWindows'][0]
216 self.nWindows = header['nNumWindows'][0]
217 self.numTaus = header['nNumTaus'][0]
217 self.numTaus = header['nNumTaus'][0]
218 self.codeType = header['nCodeType'][0]
218 self.codeType = header['nCodeType'][0]
219 self.line6Function = header['nLine6Function'][0]
219 self.line6Function = header['nLine6Function'][0]
220 self.line5Function = header['nLine5Function'][0]
220 self.line5Function = header['nLine5Function'][0]
221 self.fClock = header['fClock'][0]
221 self.fClock = header['fClock'][0]
222 self.prePulseBefore = header['nPrePulseBefore'][0]
222 self.prePulseBefore = header['nPrePulseBefore'][0]
223 self.prePulserAfter = header['nPrePulseAfter'][0]
223 self.prePulserAfter = header['nPrePulseAfter'][0]
224 self.rangeIpp = header['sRangeIPP'][0]
224 self.rangeIpp = header['sRangeIPP'][0]
225 self.rangeTxA = header['sRangeTxA'][0]
225 self.rangeTxA = header['sRangeTxA'][0]
226 self.rangeTxB = header['sRangeTxB'][0]
226 self.rangeTxB = header['sRangeTxB'][0]
227 # jump Dynamic Radar Controller Header
227 # jump Dynamic Radar Controller Header
228 jumpFp = self.size - 116
228 jumpFp = self.size - 116
229 self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
229 self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
230 #pointer backward to dynamic header and read
230 #pointer backward to dynamic header and read
231 backFp = fp.tell() - jumpFp
231 backFp = fp.tell() - jumpFp
232 fp.seek(backFp)
232 fp.seek(backFp)
233
233
234 self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
234 self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
235 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
235 self.nHeights = numpy.sum(self.samplingWindow['nsa'])
236 self.firstHeight = self.samplingWindow['h0']
236 self.firstHeight = self.samplingWindow['h0']
237 self.deltaHeight = self.samplingWindow['dh']
237 self.deltaHeight = self.samplingWindow['dh']
238 self.samplesWin = self.samplingWindow['nsa']
238 self.samplesWin = self.samplingWindow['nsa']
239
239
240 self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
240 self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
241
241
242 if self.codeType != 0:
242 if self.codeType != 0:
243 self.numCode = numpy.fromfile(fp,'<u4',1)
243 self.numCode = numpy.fromfile(fp,'<u4',1)
244 self.numBaud = numpy.fromfile(fp,'<u4',1)
244 self.numBaud = numpy.fromfile(fp,'<u4',1)
245 self.code = numpy.empty([self.numCode,self.numBaud],dtype='u1')
245 self.code = numpy.empty([self.numCode,self.numBaud],dtype='u1')
246 tempList = []
246 tempList = []
247 for ic in range(self.numCode):
247 for ic in range(self.numCode):
248 temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.numBaud/32.))
248 temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.numBaud/32.))
249 tempList.append(temp)
249 tempList.append(temp)
250 self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.numBaud:]
250 self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.numBaud:]
251 self.code = 2.0*self.code - 1.0
251 self.code = 2.0*self.code - 1.0
252
252
253 if self.line5Function == RCfunction.FLIP:
253 if self.line5Function == RCfunction.FLIP:
254 self.flip1 = numpy.fromfile(fp,'<u4',1)
254 self.flip1 = numpy.fromfile(fp,'<u4',1)
255
255
256 if self.line6Function == RCfunction.FLIP:
256 if self.line6Function == RCfunction.FLIP:
257 self.flip2 = numpy.fromfile(fp,'<u4',1)
257 self.flip2 = numpy.fromfile(fp,'<u4',1)
258
258
259 endFp = self.size + startFp
259 endFp = self.size + startFp
260 jumpFp = endFp - fp.tell()
260 jumpFp = endFp - fp.tell()
261 if jumpFp > 0:
261 if jumpFp > 0:
262 fp.seek(jumpFp)
262 fp.seek(jumpFp)
263
263
264 except:
264 except:
265 return 0
265 return 0
266
266
267 return 1
267 return 1
268
268
269 def write(self, fp):
269 def write(self, fp):
270 headerTuple = (self.size,
270 headerTuple = (self.size,
271 self.expType,
271 self.expType,
272 self.nTx,
272 self.nTx,
273 self.ipp,
273 self.ipp,
274 self.txA,
274 self.txA,
275 self.txB,
275 self.txB,
276 self.nWindows,
276 self.nWindows,
277 self.numTaus,
277 self.numTaus,
278 self.codeType,
278 self.codeType,
279 self.line6Function,
279 self.line6Function,
280 self.line5Function,
280 self.line5Function,
281 self.fClock,
281 self.fClock,
282 self.prePulseBefore,
282 self.prePulseBefore,
283 self.prePulserAfter,
283 self.prePulserAfter,
284 self.rangeIpp,
284 self.rangeIpp,
285 self.rangeTxA,
285 self.rangeTxA,
286 self.rangeTxB)
286 self.rangeTxB)
287
287
288 header = numpy.array(headerTuple,self.struct)
288 header = numpy.array(headerTuple,self.struct)
289 header.tofile(fp)
289 header.tofile(fp)
290
290
291 dynamic = self.dynamic
291 dynamic = self.dynamic
292 dynamic.tofile(fp)
292 dynamic.tofile(fp)
293
293
294 return 1
294 return 1
295
295
296
296
297
297
298 class ProcessingHeader(Header):
298 class ProcessingHeader(Header):
299
299
300 size = None
300 size = None
301 dtype = None
301 dtype = None
302 blockSize = None
302 blockSize = None
303 profilesPerBlock = None
303 profilesPerBlock = None
304 dataBlocksPerFile = None
304 dataBlocksPerFile = None
305 nWindows = None
305 nWindows = None
306 processFlags = None
306 processFlags = None
307 nCohInt = None
307 nCohInt = None
308 nIncohInt = None
308 nIncohInt = None
309 totalSpectra = None
309 totalSpectra = None
310 struct = None
310 struct = None
311 flag_dc = None
311 flag_dc = None
312 flag_cspc = None
312 flag_cspc = None
313
313
314 def __init__(self):
314 def __init__(self):
315 self.size = 0
315 self.size = 0
316 self.dataType = 0
316 self.dataType = 0
317 self.blockSize = 0
317 self.blockSize = 0
318 self.profilesPerBlock = 0
318 self.profilesPerBlock = 0
319 self.dataBlocksPerFile = 0
319 self.dataBlocksPerFile = 0
320 self.nWindows = 0
320 self.nWindows = 0
321 self.processFlags = 0
321 self.processFlags = 0
322 self.nCohInt = 0
322 self.nCohInt = 0
323 self.nIncohInt = 0
323 self.nIncohInt = 0
324 self.totalSpectra = 0
324 self.totalSpectra = 0
325 self.struct = numpy.dtype([
325 self.struct = numpy.dtype([
326 ('nSize','<u4'),
326 ('nSize','<u4'),
327 ('nDataType','<u4'),
327 ('nDataType','<u4'),
328 ('nSizeOfDataBlock','<u4'),
328 ('nSizeOfDataBlock','<u4'),
329 ('nProfilesperBlock','<u4'),
329 ('nProfilesperBlock','<u4'),
330 ('nDataBlocksperFile','<u4'),
330 ('nDataBlocksperFile','<u4'),
331 ('nNumWindows','<u4'),
331 ('nNumWindows','<u4'),
332 ('nProcessFlags','<u4'),
332 ('nProcessFlags','<u4'),
333 ('nCoherentIntegrations','<u4'),
333 ('nCoherentIntegrations','<u4'),
334 ('nIncoherentIntegrations','<u4'),
334 ('nIncoherentIntegrations','<u4'),
335 ('nTotalSpectra','<u4')
335 ('nTotalSpectra','<u4')
336 ])
336 ])
337 self.samplingWindow = 0
337 self.samplingWindow = 0
338 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
338 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
339 self.numHeights = 0
339 self.nHeights = 0
340 self.firstHeight = 0
340 self.firstHeight = 0
341 self.deltaHeight = 0
341 self.deltaHeight = 0
342 self.samplesWin = 0
342 self.samplesWin = 0
343 self.spectraComb = 0
343 self.spectraComb = 0
344 self.numCode = 0
344 self.numCode = 0
345 self.code = 0
345 self.code = 0
346 self.numBaud = 0
346 self.numBaud = 0
347 self.shif_fft = False
347 self.shif_fft = False
348 self.flag_dc = False
348 self.flag_dc = False
349 self.flag_cspc = False
349 self.flag_cspc = False
350
350
351 def read(self, fp):
351 def read(self, fp):
352 try:
352 try:
353 header = numpy.fromfile(fp,self.struct,1)
353 header = numpy.fromfile(fp,self.struct,1)
354 self.size = header['nSize'][0]
354 self.size = header['nSize'][0]
355 self.dataType = header['nDataType'][0]
355 self.dataType = header['nDataType'][0]
356 self.blockSize = header['nSizeOfDataBlock'][0]
356 self.blockSize = header['nSizeOfDataBlock'][0]
357 self.profilesPerBlock = header['nProfilesperBlock'][0]
357 self.profilesPerBlock = header['nProfilesperBlock'][0]
358 self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
358 self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
359 self.nWindows = header['nNumWindows'][0]
359 self.nWindows = header['nNumWindows'][0]
360 self.processFlags = header['nProcessFlags']
360 self.processFlags = header['nProcessFlags']
361 self.nCohInt = header['nCoherentIntegrations'][0]
361 self.nCohInt = header['nCoherentIntegrations'][0]
362 self.nIncohInt = header['nIncoherentIntegrations'][0]
362 self.nIncohInt = header['nIncoherentIntegrations'][0]
363 self.totalSpectra = header['nTotalSpectra'][0]
363 self.totalSpectra = header['nTotalSpectra'][0]
364 self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
364 self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
365 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
365 self.nHeights = numpy.sum(self.samplingWindow['nsa'])
366 self.firstHeight = self.samplingWindow['h0']
366 self.firstHeight = self.samplingWindow['h0'][0]
367 self.deltaHeight = self.samplingWindow['dh']
367 self.deltaHeight = self.samplingWindow['dh'][0]
368 self.samplesWin = self.samplingWindow['nsa']
368 self.samplesWin = self.samplingWindow['nsa']
369 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
369 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
370
370
371 if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
371 if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
372 self.numCode = numpy.fromfile(fp,'<u4',1)
372 self.numCode = numpy.fromfile(fp,'<u4',1)
373 self.numBaud = numpy.fromfile(fp,'<u4',1)
373 self.numBaud = numpy.fromfile(fp,'<u4',1)
374 self.code = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode)
374 self.code = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode)
375
375
376 if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
376 if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
377 self.shif_fft = True
377 self.shif_fft = True
378 else:
378 else:
379 self.shif_fft = False
379 self.shif_fft = False
380
380
381 if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
381 if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
382 self.flag_dc = True
382 self.flag_dc = True
383
383
384 nChannels = 0
384 nChannels = 0
385 nPairs = 0
385 nPairs = 0
386 pairList = []
386 pairList = []
387
387
388 for i in range( 0, self.totalSpectra*2, 2 ):
388 for i in range( 0, self.totalSpectra*2, 2 ):
389 if self.spectraComb[i] == self.spectraComb[i+1]:
389 if self.spectraComb[i] == self.spectraComb[i+1]:
390 nChannels = nChannels + 1 #par de canales iguales
390 nChannels = nChannels + 1 #par de canales iguales
391 else:
391 else:
392 nPairs = nPairs + 1 #par de canales diferentes
392 nPairs = nPairs + 1 #par de canales diferentes
393 pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
393 pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
394
394
395 self.flag_cspc = False
395 self.flag_cspc = False
396 if nPairs > 0:
396 if nPairs > 0:
397 self.flag_cspc = True
397 self.flag_cspc = True
398
398
399 except:
399 except:
400 return 0
400 return 0
401
401
402 return 1
402 return 1
403
403
404 def write(self, fp):
404 def write(self, fp):
405 headerTuple = (self.size,
405 headerTuple = (self.size,
406 self.dataType,
406 self.dataType,
407 self.blockSize,
407 self.blockSize,
408 self.profilesPerBlock,
408 self.profilesPerBlock,
409 self.dataBlocksPerFile,
409 self.dataBlocksPerFile,
410 self.nWindows,
410 self.nWindows,
411 self.processFlags,
411 self.processFlags,
412 self.nCohInt,
412 self.nCohInt,
413 self.nIncohInt,
413 self.nIncohInt,
414 self.totalSpectra)
414 self.totalSpectra)
415
415
416 header = numpy.array(headerTuple,self.struct)
416 header = numpy.array(headerTuple,self.struct)
417 header.tofile(fp)
417 header.tofile(fp)
418
418
419 if self.nWindows != 0:
419 if self.nWindows != 0:
420 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
420 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
421 samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
421 samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
422 samplingWindow.tofile(fp)
422 samplingWindow.tofile(fp)
423
423
424
424
425 if self.totalSpectra != 0:
425 if self.totalSpectra != 0:
426 spectraComb = numpy.array([],numpy.dtype('u1'))
426 spectraComb = numpy.array([],numpy.dtype('u1'))
427 spectraComb = self.spectraComb
427 spectraComb = self.spectraComb
428 spectraComb.tofile(fp)
428 spectraComb.tofile(fp)
429
429
430
430
431 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
431 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
432 numCode = self.numCode
432 numCode = self.numCode
433 numCode.tofile(fp)
433 numCode.tofile(fp)
434
434
435 numBaud = self.numBaud
435 numBaud = self.numBaud
436 numBaud.tofile(fp)
436 numBaud.tofile(fp)
437
437
438 code = self.code.reshape(numCode*numBaud)
438 code = self.code.reshape(numCode*numBaud)
439 code.tofile(fp)
439 code.tofile(fp)
440
440
441 return 1
441 return 1
442
442
443 class RCfunction:
443 class RCfunction:
444 NONE=0
444 NONE=0
445 FLIP=1
445 FLIP=1
446 CODE=2
446 CODE=2
447 SAMPLING=3
447 SAMPLING=3
448 LIN6DIV256=4
448 LIN6DIV256=4
449 SYNCHRO=5
449 SYNCHRO=5
450
450
451 class nCodeType:
451 class nCodeType:
452 NONE=0
452 NONE=0
453 USERDEFINE=1
453 USERDEFINE=1
454 BARKER2=2
454 BARKER2=2
455 BARKER3=3
455 BARKER3=3
456 BARKER4=4
456 BARKER4=4
457 BARKER5=5
457 BARKER5=5
458 BARKER7=6
458 BARKER7=6
459 BARKER11=7
459 BARKER11=7
460 BARKER13=8
460 BARKER13=8
461 AC128=9
461 AC128=9
462 COMPLEMENTARYCODE2=10
462 COMPLEMENTARYCODE2=10
463 COMPLEMENTARYCODE4=11
463 COMPLEMENTARYCODE4=11
464 COMPLEMENTARYCODE8=12
464 COMPLEMENTARYCODE8=12
465 COMPLEMENTARYCODE16=13
465 COMPLEMENTARYCODE16=13
466 COMPLEMENTARYCODE32=14
466 COMPLEMENTARYCODE32=14
467 COMPLEMENTARYCODE64=15
467 COMPLEMENTARYCODE64=15
468 COMPLEMENTARYCODE128=16
468 COMPLEMENTARYCODE128=16
469 CODE_BINARY28=17
469 CODE_BINARY28=17
470
470
471 class PROCFLAG:
471 class PROCFLAG:
472 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
472 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
473 DECODE_DATA = numpy.uint32(0x00000002)
473 DECODE_DATA = numpy.uint32(0x00000002)
474 SPECTRA_CALC = numpy.uint32(0x00000004)
474 SPECTRA_CALC = numpy.uint32(0x00000004)
475 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
475 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
476 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
476 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
477 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
477 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
478
478
479 DATATYPE_CHAR = numpy.uint32(0x00000040)
479 DATATYPE_CHAR = numpy.uint32(0x00000040)
480 DATATYPE_SHORT = numpy.uint32(0x00000080)
480 DATATYPE_SHORT = numpy.uint32(0x00000080)
481 DATATYPE_LONG = numpy.uint32(0x00000100)
481 DATATYPE_LONG = numpy.uint32(0x00000100)
482 DATATYPE_INT64 = numpy.uint32(0x00000200)
482 DATATYPE_INT64 = numpy.uint32(0x00000200)
483 DATATYPE_FLOAT = numpy.uint32(0x00000400)
483 DATATYPE_FLOAT = numpy.uint32(0x00000400)
484 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
484 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
485
485
486 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
486 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
487 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
487 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
488 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
488 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
489
489
490 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
490 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
491 DEFLIP_DATA = numpy.uint32(0x00010000)
491 DEFLIP_DATA = numpy.uint32(0x00010000)
492 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
492 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
493
493
494 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
494 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
495 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
495 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
496 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
496 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
497 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
497 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
498 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
498 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
499
499
500 EXP_NAME_ESP = numpy.uint32(0x00200000)
500 EXP_NAME_ESP = numpy.uint32(0x00200000)
501 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
501 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
502
502
503 OPERATION_MASK = numpy.uint32(0x0000003F)
503 OPERATION_MASK = numpy.uint32(0x0000003F)
504 DATATYPE_MASK = numpy.uint32(0x00000FC0)
504 DATATYPE_MASK = numpy.uint32(0x00000FC0)
505 DATAARRANGE_MASK = numpy.uint32(0x00007000)
505 DATAARRANGE_MASK = numpy.uint32(0x00007000)
506 ACQ_SYS_MASK = numpy.uint32(0x001C0000) No newline at end of file
506 ACQ_SYS_MASK = numpy.uint32(0x001C0000)
Show file before | Show file after | Hide comments
@@ -1,494 +1,490
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author $Author: dsuarez $
4 @author $Author: dsuarez $
5 @version $Id: VoltageIO.py 110 2012-07-19 15:18:18Z dsuarez $
5 @version $Id: VoltageIO.py 110 2012-07-19 15:18:18Z dsuarez $
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 JROHeader import *
17 from JROHeader import *
18 from JRODataIO import JRODataReader
18 from JRODataIO import JRODataReader
19 from JRODataIO import JRODataWriter
19 from JRODataIO import JRODataWriter
20
20
21 from Data.Voltage import Voltage
21 from Data.Voltage import Voltage
22
22
23 class VoltageReader(JRODataReader):
23 class VoltageReader(JRODataReader):
24 """
24 """
25 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
25 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:
26 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".
27 perfiles*alturas*canales) son almacenados en la variable "buffer".
28
28
29 perfiles * alturas * canales
29 perfiles * alturas * canales
30
30
31 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
31 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
32 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
32 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
33 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
33 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
34 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
34 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
35
35
36 Example:
36 Example:
37
37
38 dpath = "/home/myuser/data"
38 dpath = "/home/myuser/data"
39
39
40 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
40 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
41
41
42 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
42 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
43
43
44 readerObj = VoltageReader()
44 readerObj = VoltageReader()
45
45
46 readerObj.setup(dpath, startTime, endTime)
46 readerObj.setup(dpath, startTime, endTime)
47
47
48 while(True):
48 while(True):
49
49
50 #to get one profile
50 #to get one profile
51 profile = readerObj.getData()
51 profile = readerObj.getData()
52
52
53 #print the profile
53 #print the profile
54 print profile
54 print profile
55
55
56 #If you want to see all datablock
56 #If you want to see all datablock
57 print readerObj.datablock
57 print readerObj.datablock
58
58
59 if readerObj.flagNoMoreFiles:
59 if readerObj.flagNoMoreFiles:
60 break
60 break
61
61
62 """
62 """
63 dataOutObj = None
63 dataOutObj = None
64
64
65 datablock = None
65 datablock = None
66
66
67 ext = ".r"
67 ext = ".r"
68
68
69 optchar = "D"
69 optchar = "D"
70
70
71
71
72 def __init__(self, dataOutObj=None):
72 def __init__(self, dataOutObj=None):
73 """
73 """
74 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
74 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
75
75
76 Input:
76 Input:
77 dataOutObj : Objeto de la clase Voltage. Este objeto sera utilizado para
77 dataOutObj : Objeto de la clase Voltage. Este objeto sera utilizado para
78 almacenar un perfil de datos cada vez que se haga un requerimiento
78 almacenar un perfil de datos cada vez que se haga un requerimiento
79 (getData). El perfil sera obtenido a partir del buffer de datos,
79 (getData). El perfil sera obtenido a partir del buffer de datos,
80 si el buffer esta vacio se hara un nuevo proceso de lectura de un
80 si el buffer esta vacio se hara un nuevo proceso de lectura de un
81 bloque de datos.
81 bloque de datos.
82 Si este parametro no es pasado se creara uno internamente.
82 Si este parametro no es pasado se creara uno internamente.
83
83
84 Variables afectadas:
84 Variables afectadas:
85 self.dataOutObj
85 self.dataOutObj
86
86
87 Return:
87 Return:
88 None
88 None
89 """
89 """
90
90
91 self.datablock = None
91 self.datablock = None
92
92
93 self.utc = 0
93 self.utc = 0
94
94
95 self.ext = ".r"
95 self.ext = ".r"
96
96
97 self.optchar = "D"
97 self.optchar = "D"
98
98
99 self.basicHeaderObj = BasicHeader()
99 self.basicHeaderObj = BasicHeader()
100
100
101 self.systemHeaderObj = SystemHeader()
101 self.systemHeaderObj = SystemHeader()
102
102
103 self.radarControllerHeaderObj = RadarControllerHeader()
103 self.radarControllerHeaderObj = RadarControllerHeader()
104
104
105 self.processingHeaderObj = ProcessingHeader()
105 self.processingHeaderObj = ProcessingHeader()
106
106
107 self.online = 0
107 self.online = 0
108
108
109 self.fp = None
109 self.fp = None
110
110
111 self.idFile = None
111 self.idFile = None
112
112
113 self.startDateTime = None
114
115 self.endDateTime = None
116
117 self.dtype = None
113 self.dtype = None
118
114
119 self.fileSizeByHeader = None
115 self.fileSizeByHeader = None
120
116
121 self.filenameList = []
117 self.filenameList = []
122
118
123 self.filename = None
119 self.filename = None
124
120
125 self.fileSize = None
121 self.fileSize = None
126
122
127 self.firstHeaderSize = 0
123 self.firstHeaderSize = 0
128
124
129 self.basicHeaderSize = 24
125 self.basicHeaderSize = 24
130
126
131 self.pathList = []
127 self.pathList = []
132
128
133 self.filenameList = []
129 self.filenameList = []
134
130
135 self.lastUTTime = 0
131 self.lastUTTime = 0
136
132
137 self.maxTimeStep = 30
133 self.maxTimeStep = 30
138
134
139 self.flagNoMoreFiles = 0
135 self.flagNoMoreFiles = 0
140
136
141 self.set = 0
137 self.set = 0
142
138
143 self.path = None
139 self.path = None
144
140
145 self.profileIndex = 9999
141 self.profileIndex = 9999
146
142
147 self.delay = 3 #seconds
143 self.delay = 3 #seconds
148
144
149 self.nTries = 3 #quantity tries
145 self.nTries = 3 #quantity tries
150
146
151 self.nFiles = 3 #number of files for searching
147 self.nFiles = 3 #number of files for searching
152
148
153 self.nReadBlocks = 0
149 self.nReadBlocks = 0
154
150
155 self.flagIsNewFile = 1
151 self.flagIsNewFile = 1
156
152
157 self.ippSeconds = 0
153 self.ippSeconds = 0
158
154
159 self.flagTimeBlock = 0
155 self.flagTimeBlock = 0
160
156
161 self.flagIsNewBlock = 0
157 self.flagIsNewBlock = 0
162
158
163 self.nTotalBlocks = 0
159 self.nTotalBlocks = 0
164
160
165 self.blocksize = 0
161 self.blocksize = 0
166
162
167 def createObjByDefault(self):
163 def createObjByDefault(self):
168
164
169 dataObj = Voltage()
165 dataObj = Voltage()
170
166
171 return dataObj
167 return dataObj
172
168
173 def __hasNotDataInBuffer(self):
169 def __hasNotDataInBuffer(self):
174 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
170 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
175 return 1
171 return 1
176 return 0
172 return 0
177
173
178
174
179 def getBlockDimension(self):
175 def getBlockDimension(self):
180 """
176 """
181 Obtiene la cantidad de puntos a leer por cada bloque de datos
177 Obtiene la cantidad de puntos a leer por cada bloque de datos
182
178
183 Affected:
179 Affected:
184 self.blocksize
180 self.blocksize
185
181
186 Return:
182 Return:
187 None
183 None
188 """
184 """
189 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.numHeights * self.systemHeaderObj.numChannels
185 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
190 self.blocksize = pts2read
186 self.blocksize = pts2read
191
187
192
188
193 def readBlock(self):
189 def readBlock(self):
194 """
190 """
195 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
191 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
196 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
192 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
197 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
193 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
198 es seteado a 0
194 es seteado a 0
199
195
200 Inputs:
196 Inputs:
201 None
197 None
202
198
203 Return:
199 Return:
204 None
200 None
205
201
206 Affected:
202 Affected:
207 self.profileIndex
203 self.profileIndex
208 self.datablock
204 self.datablock
209 self.flagIsNewFile
205 self.flagIsNewFile
210 self.flagIsNewBlock
206 self.flagIsNewBlock
211 self.nTotalBlocks
207 self.nTotalBlocks
212
208
213 Exceptions:
209 Exceptions:
214 Si un bloque leido no es un bloque valido
210 Si un bloque leido no es un bloque valido
215 """
211 """
216
212
217 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
213 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
218
214
219 try:
215 try:
220 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.numHeights, self.systemHeaderObj.numChannels) )
216 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
221 except:
217 except:
222 print "The read block (%3d) has not enough data" %self.nReadBlocks
218 print "The read block (%3d) has not enough data" %self.nReadBlocks
223 return 0
219 return 0
224
220
225 junk = numpy.transpose(junk, (2,0,1))
221 junk = numpy.transpose(junk, (2,0,1))
226 self.datablock = junk['real'] + junk['imag']*1j
222 self.datablock = junk['real'] + junk['imag']*1j
227
223
228 self.profileIndex = 0
224 self.profileIndex = 0
229
225
230 self.flagIsNewFile = 0
226 self.flagIsNewFile = 0
231 self.flagIsNewBlock = 1
227 self.flagIsNewBlock = 1
232
228
233 self.nTotalBlocks += 1
229 self.nTotalBlocks += 1
234 self.nReadBlocks += 1
230 self.nReadBlocks += 1
235
231
236 return 1
232 return 1
237
233
238
234
239 def getData(self):
235 def getData(self):
240 """
236 """
241 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
237 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
242 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
238 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
243 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
239 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
244
240
245 Ademas incrementa el contador del buffer en 1.
241 Ademas incrementa el contador del buffer en 1.
246
242
247 Return:
243 Return:
248 data : retorna un perfil de voltages (alturas * canales) copiados desde el
244 data : retorna un perfil de voltages (alturas * canales) copiados desde el
249 buffer. Si no hay mas archivos a leer retorna None.
245 buffer. Si no hay mas archivos a leer retorna None.
250
246
251 Variables afectadas:
247 Variables afectadas:
252 self.dataOutObj
248 self.dataOutObj
253 self.profileIndex
249 self.profileIndex
254
250
255 Affected:
251 Affected:
256 self.dataOutObj
252 self.dataOutObj
257 self.profileIndex
253 self.profileIndex
258 self.flagTimeBlock
254 self.flagTimeBlock
259 self.flagIsNewBlock
255 self.flagIsNewBlock
260 """
256 """
261 if self.flagNoMoreFiles: return 0
257 if self.flagNoMoreFiles: return 0
262
258
263 self.flagTimeBlock = 0
259 self.flagTimeBlock = 0
264 self.flagIsNewBlock = 0
260 self.flagIsNewBlock = 0
265
261
266 if self.__hasNotDataInBuffer():
262 if self.__hasNotDataInBuffer():
267
263
268 if not( self.readNextBlock() ):
264 if not( self.readNextBlock() ):
269 return 0
265 return 0
270
266
271 self.updateDataHeader()
267 # self.updateDataHeader()
272
268
273 if self.flagNoMoreFiles == 1:
269 if self.flagNoMoreFiles == 1:
274 print 'Process finished'
270 print 'Process finished'
275 return 0
271 return 0
276
272
277 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
273 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
278
274
279 if self.datablock == None:
275 if self.datablock == None:
280 self.dataOutObj.flagNoData = True
276 self.dataOutObj.flagNoData = True
281 return 0
277 return 0
282
278
283 self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
279 self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
284
280
285 self.dataOutObj.dtype = self.dtype
281 self.dataOutObj.dtype = self.dtype
286
282
287 self.dataOutObj.nChannels = self.systemHeaderObj.numChannels
283 self.dataOutObj.nChannels = self.systemHeaderObj.nChannels
288
284
289 self.dataOutObj.nHeights = self.processingHeaderObj.numHeights
285 self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
290
286
291 self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
287 self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
292
288
293 xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.numHeights*self.processingHeaderObj.deltaHeight
289 xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
294
290
295 self.dataOutObj.heightList = range(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
291 self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
296
292
297 self.dataOutObj.channelList = range(self.systemHeaderObj.numChannels)
293 self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
298
294
299 self.dataOutObj.channelIndexList = range(self.systemHeaderObj.numChannels)
295 self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
300
296
301 self.dataOutObj.flagNoData = True
297 self.dataOutObj.flagNoData = True
302
298
303 self.dataOutObj.flagTimeBlock = self.flagTimeBlock
299 self.dataOutObj.flagTimeBlock = self.flagTimeBlock
304
300
305 self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.profileIndex * self.ippSeconds
301 self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.profileIndex * self.ippSeconds
306
302
307 self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
303 self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
308
304
309 self.profileIndex += 1
305 self.profileIndex += 1
310
306
311 self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
307 self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
312
308
313 self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
309 self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
314
310
315 return 1
311 return 1
316
312
317
313
318 class VoltageWriter(JRODataWriter):
314 class VoltageWriter(JRODataWriter):
319 """
315 """
320 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
316 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
321 de los datos siempre se realiza por bloques.
317 de los datos siempre se realiza por bloques.
322 """
318 """
323 __configHeaderFile = 'wrSetHeadet.txt'
319 __configHeaderFile = 'wrSetHeadet.txt'
324
320
325 dataOutObj = None
321 dataOutObj = None
326
322
327 ext = ".r"
323 ext = ".r"
328
324
329 optchar = "D"
325 optchar = "D"
330
326
331 datablock = None
327 datablock = None
332
328
333 profileIndex = 0
329 profileIndex = 0
334
330
335 shapeBuffer = None
331 shapeBuffer = None
336
332
337
333
338 def __init__(self, dataOutObj=None):
334 def __init__(self, dataOutObj=None):
339 """
335 """
340 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
336 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
341
337
342 Affected:
338 Affected:
343 self.dataOutObj
339 self.dataOutObj
344
340
345 Return: None
341 Return: None
346 """
342 """
347 if dataOutObj == None:
343 if dataOutObj == None:
348 dataOutObj = Voltage()
344 dataOutObj = Voltage()
349
345
350 if not( isinstance(dataOutObj, Voltage) ):
346 if not( isinstance(dataOutObj, Voltage) ):
351 raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
347 raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
352
348
353 self.dataOutObj = dataOutObj
349 self.dataOutObj = dataOutObj
354
350
355
351
356 def hasAllDataInBuffer(self):
352 def hasAllDataInBuffer(self):
357 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
353 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
358 return 1
354 return 1
359 return 0
355 return 0
360
356
361
357
362 def setBlockDimension(self):
358 def setBlockDimension(self):
363 """
359 """
364 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
360 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
365
361
366 Affected:
362 Affected:
367 self.shape_spc_Buffer
363 self.shape_spc_Buffer
368 self.shape_cspc_Buffer
364 self.shape_cspc_Buffer
369 self.shape_dc_Buffer
365 self.shape_dc_Buffer
370
366
371 Return: None
367 Return: None
372 """
368 """
373 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
369 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
374 self.processingHeaderObj.numHeights,
370 self.processingHeaderObj.nHeights,
375 self.systemHeaderObj.numChannels )
371 self.systemHeaderObj.nChannels )
376
372
377 self.datablock = numpy.zeros((self.systemHeaderObj.numChannels,
373 self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
378 self.processingHeaderObj.profilesPerBlock,
374 self.processingHeaderObj.profilesPerBlock,
379 self.processingHeaderObj.numHeights),
375 self.processingHeaderObj.nHeights),
380 dtype=numpy.dtype('complex'))
376 dtype=numpy.dtype('complex'))
381
377
382
378
383 def writeBlock(self):
379 def writeBlock(self):
384 """
380 """
385 Escribe el buffer en el file designado
381 Escribe el buffer en el file designado
386
382
387 Affected:
383 Affected:
388 self.profileIndex
384 self.profileIndex
389 self.flagIsNewFile
385 self.flagIsNewFile
390 self.flagIsNewBlock
386 self.flagIsNewBlock
391 self.nTotalBlocks
387 self.nTotalBlocks
392 self.blockIndex
388 self.blockIndex
393
389
394 Return: None
390 Return: None
395 """
391 """
396 data = numpy.zeros( self.shapeBuffer, self.dtype )
392 data = numpy.zeros( self.shapeBuffer, self.dtype )
397
393
398 junk = numpy.transpose(self.datablock, (1,2,0))
394 junk = numpy.transpose(self.datablock, (1,2,0))
399
395
400 data['real'] = junk.real
396 data['real'] = junk.real
401 data['imag'] = junk.imag
397 data['imag'] = junk.imag
402
398
403 data = data.reshape( (-1) )
399 data = data.reshape( (-1) )
404
400
405 data.tofile( self.fp )
401 data.tofile( self.fp )
406
402
407 self.datablock.fill(0)
403 self.datablock.fill(0)
408
404
409 self.profileIndex = 0
405 self.profileIndex = 0
410 self.flagIsNewFile = 0
406 self.flagIsNewFile = 0
411 self.flagIsNewBlock = 1
407 self.flagIsNewBlock = 1
412
408
413 self.blockIndex += 1
409 self.blockIndex += 1
414 self.nTotalBlocks += 1
410 self.nTotalBlocks += 1
415
411
416 def putData(self):
412 def putData(self):
417 """
413 """
418 Setea un bloque de datos y luego los escribe en un file
414 Setea un bloque de datos y luego los escribe en un file
419
415
420 Affected:
416 Affected:
421 self.flagIsNewBlock
417 self.flagIsNewBlock
422 self.profileIndex
418 self.profileIndex
423
419
424 Return:
420 Return:
425 0 : Si no hay data o no hay mas files que puedan escribirse
421 0 : Si no hay data o no hay mas files que puedan escribirse
426 1 : Si se escribio la data de un bloque en un file
422 1 : Si se escribio la data de un bloque en un file
427 """
423 """
428 self.flagIsNewBlock = 0
424 self.flagIsNewBlock = 0
429
425
430 if self.dataOutObj.flagNoData:
426 if self.dataOutObj.flagNoData:
431 return 0
427 return 0
432
428
433 if self.dataOutObj.flagTimeBlock:
429 if self.dataOutObj.flagTimeBlock:
434
430
435 self.datablock.fill(0)
431 self.datablock.fill(0)
436 self.profileIndex = 0
432 self.profileIndex = 0
437 self.setNextFile()
433 self.setNextFile()
438
434
439 self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
435 self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
440
436
441 self.profileIndex += 1
437 self.profileIndex += 1
442
438
443 if self.hasAllDataInBuffer():
439 if self.hasAllDataInBuffer():
444 #if self.flagIsNewFile:
440 #if self.flagIsNewFile:
445 self.getDataHeader()
441 self.getDataHeader()
446 self.writeNextBlock()
442 self.writeNextBlock()
447
443
448 if self.flagNoMoreFiles:
444 if self.flagNoMoreFiles:
449 #print 'Process finished'
445 #print 'Process finished'
450 return 0
446 return 0
451
447
452 return 1
448 return 1
453
449
454 def getDataHeader(self):
450 def getDataHeader(self):
455
451
456 """
452 """
457 Obtiene una copia del First Header
453 Obtiene una copia del First Header
458
454
459 Affected:
455 Affected:
460 self.systemHeaderObj
456 self.systemHeaderObj
461 self.radarControllerHeaderObj
457 self.radarControllerHeaderObj
462 self.dtype
458 self.dtype
463
459
464 Return:
460 Return:
465 None
461 None
466 """
462 """
467
463
468 # CALCULAR PARAMETROS
464 # CALCULAR PARAMETROS
469
465
470 self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
466 self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
471 self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
467 self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
472
468
473 self.basicHeaderObj.size = self.basicHeaderSize
469 self.basicHeaderObj.size = self.basicHeaderSize
474 self.basicHeaderObj.version = self.versionFile
470 self.basicHeaderObj.version = self.versionFile
475 self.basicHeaderObj.dataBlock = self.nTotalBlocks
471 self.basicHeaderObj.dataBlock = self.nTotalBlocks
476 self.basicHeaderObj.utc = self.dataOutObj.dataUtcTime
472 self.basicHeaderObj.utc = self.dataOutObj.dataUtcTime
477 self.basicHeaderObj.miliSecond = 0
473 self.basicHeaderObj.miliSecond = 0
478 self.basicHeaderObj.timeZone = 0
474 self.basicHeaderObj.timeZone = 0
479 self.basicHeaderObj.dstFlag = 0
475 self.basicHeaderObj.dstFlag = 0
480 self.basicHeaderObj.errorCount = 0
476 self.basicHeaderObj.errorCount = 0
481
477
482 self.processingHeaderObj.size = 0
478 self.processingHeaderObj.size = 0
483 self.processingHeaderObj.dtype = self.dataOutObj.dtype
479 self.processingHeaderObj.dtype = self.dataOutObj.dtype
484 self.processingHeaderObj.blockSize = 0
480 self.processingHeaderObj.blockSize = 0
485 self.processingHeaderObj.profilesPerBlock = 0
481 self.processingHeaderObj.profilesPerBlock = 0
486 self.processingHeaderObj.dataBlocksPerFile = 0
482 self.processingHeaderObj.dataBlocksPerFile = 0
487 self.processingHeaderObj.numWindows = 0
483 self.processingHeaderObj.numWindows = 0
488 self.processingHeaderObj.processFlags = 0
484 self.processingHeaderObj.processFlags = 0
489 self.processingHeaderObj.coherentInt = 0
485 self.processingHeaderObj.coherentInt = 0
490 self.processingHeaderObj.incoherentInt = 0
486 self.processingHeaderObj.incoherentInt = 0
491 self.processingHeaderObj.totalSpectra = 0
487 self.processingHeaderObj.totalSpectra = 0
492
488
493 self.dtype = self.dataOutObj.dtype
489 self.dtype = self.dataOutObj.dtype
494 No newline at end of file
490
Show file before | Show file after | Hide comments
@@ -1,65 +1,65
1
1
2 import os, sys
2 import os, sys
3 import time, datetime
3 import time, datetime
4
4
5 path = os.path.split(os.getcwd())[0]
5 path = os.path.split(os.getcwd())[0]
6 sys.path.append(path)
6 sys.path.append(path)
7
7
8 from Data.Voltage import Voltage
8 from Data.Voltage import Voltage
9 from IO.VoltageIO import *
9 from IO.VoltageIO import *
10
10
11 from Processing.VoltageProcessor import *
11 from Processing.VoltageProcessor import *
12
12
13
13
14
14
15 class TestSChain():
15 class TestSChain():
16
16
17 def __init__(self):
17 def __init__(self):
18 self.setValues()
18 self.setValues()
19 self.createObjects()
19 self.createObjects()
20 self.testSChain()
20 self.testSChain()
21
21
22 def setValues(self):
22 def setValues(self):
23 self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
23 self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
24 self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING"
24 # self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING"
25
25
26 self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
26 self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
27
27
28 self.startDate = datetime.date(2009,1,17)
28 self.startDate = datetime.date(2009,1,17)
29 self.endDate = datetime.date(2009,1,17)
29 self.endDate = datetime.date(2009,1,17)
30
30
31 self.startTime = datetime.time(0,0,0)
31 self.startTime = datetime.time(0,0,0)
32 self.endTime = datetime.time(14,1,1)
32 self.endTime = datetime.time(14,1,1)
33
33
34 def createObjects(self):
34 def createObjects(self):
35
35
36 self.readerObj = VoltageReader()
36 self.readerObj = VoltageReader()
37
37
38 self.voltObj1 = self.readerObj.setup(
38 self.voltObj1 = self.readerObj.setup(
39 path = self.path,
39 path = self.path,
40 startDate = self.startDate,
40 startDate = self.startDate,
41 endDate = self.endDate,
41 endDate = self.endDate,
42 startTime = self.startTime,
42 startTime = self.startTime,
43 endTime = self.endTime,
43 endTime = self.endTime,
44 expLabel = '',
44 expLabel = '',
45 online = 0)
45 online = 0)
46
46
47
47
48
48
49 def testSChain(self):
49 def testSChain(self):
50
50
51 ini = time.time()
51 ini = time.time()
52
52
53 while(True):
53 while(True):
54 self.readerObj.getData()
54 self.readerObj.getData()
55
55
56 if self.readerObj.flagNoMoreFiles:
56 if self.readerObj.flagNoMoreFiles:
57 break
57 break
58
58
59 if self.readerObj.flagIsNewBlock:
59 if self.readerObj.flagIsNewBlock:
60 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
60 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
61 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
61 datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
62
62
63
63
64 if __name__ == '__main__':
64 if __name__ == '__main__':
65 TestSChain() No newline at end of file
65 TestSChain()
General Comments 0
You need to be logged in to leave comments. Login now