##// END OF EJS Templates
schain-jc
RSS
Se ha reordenado las variables
Miguel Valdez -
r89:b509e99f0d8d
parent child
Show More
Show file before | Show file after | Hide comments
@@ -136,7 +136,7 class Spectrum():
136 nChan, nX, nY = numpy.shape(data)
136 nChan, nX, nY = numpy.shape(data)
137
137
138 x = numpy.arange(nX)
138 x = numpy.arange(nX)
139 y = self.m_Spectra.heights
139 y = self.m_Spectra.heightList
140
140
141 thisDatetime = datetime.datetime.fromtimestamp(self.m_Spectra.m_BasicHeader.utc)
141 thisDatetime = datetime.datetime.fromtimestamp(self.m_Spectra.m_BasicHeader.utc)
142 txtDate = "Self Spectra - Date: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
142 txtDate = "Self Spectra - Date: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
Show file before | Show file after | Hide comments
@@ -9,9 +9,22 from DataIO import DataReader
9 from DataIO import DataWriter
9 from DataIO import DataWriter
10
10
11 class CorrelationReader(DataReader):
11 class CorrelationReader(DataReader):
12
12 def __init__(self):
13 def __init__(self):
14
13 pass
15 pass
14
16
15 class CorrelationWriter(DataWriter):
17 class CorrelationWriter(DataWriter):
18
16 def __init__(self):
19 def __init__(self):
17 pass No newline at end of file
20
21 pass
22
23 def puData(self):
24 pass
25
26 def writeBlock(self):
27 pass
28
29
30 No newline at end of file
Show file before | Show file after | Hide comments
@@ -166,40 +166,10 def getlastFileFromPath(path, ext):
166
166
167 return None
167 return None
168
168
169
169 class JRODataIO():
170 class DataReader():
171
172 def __init__(self):
173 pass
174
175
176 class DataWriter():
177
178 def __init__(self):
179 pass
180
181
170
182 class JRODataReader(DataReader):
171 #speed of light
183
172 c = 3E8
184 """
185 Esta clase es usada como la clase padre de las clases DataReader,
186 contiene todos lo metodos necesarios para leer datos desde archivos en formato
187 jicamarca o pdata (.r o .pdata). La lectura de los datos siempre se realiza por bloques. Los datos
188 leidos son array de 3 dimensiones:
189
190 Para Voltajes - perfiles * alturas * canales
191
192 Para Spectra - paresCanalesIguales * alturas * perfiles (Self Spectra)
193 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
194 canales * alturas (DC Channels)
195
196 y son almacenados en su buffer respectivo.
197
198 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
199 RadarControllerHeader y DataObj. Los tres primeros se usan para almacenar informacion de la
200 cabecera de datos (metadata), y el cuarto (DataObj) para obtener y almacenar los datos desde
201 el buffer cada vez que se ejecute el metodo "getData".
202 """
203
173
204 m_BasicHeader = BasicHeader()
174 m_BasicHeader = BasicHeader()
205
175
@@ -211,14 +181,12 class JRODataReader(DataReader):
211
181
212 m_DataObj = None
182 m_DataObj = None
213
183
214 heightList = None
215
216 channelList = None
217
218 online = 0
184 online = 0
219
185
220 fp = None
186 fp = None
221
187
188 dataType = None
189
222 fileSizeByHeader = None
190 fileSizeByHeader = None
223
191
224 filenameList = []
192 filenameList = []
@@ -231,11 +199,11 class JRODataReader(DataReader):
231
199
232 basicHeaderSize = 24
200 basicHeaderSize = 24
233
201
234 dataType = None
202 nTotalBlocks = 0
203
204 ippSeconds = 0
235
205
236 maxTimeStep = 30
206 blocksize = 0
237
238 flagNoMoreFiles = 0
239
207
240 set = 0
208 set = 0
241
209
@@ -243,47 +211,75 class JRODataReader(DataReader):
243
211
244 path = None
212 path = None
245
213
214 maxTimeStep = 30
215
216
246 delay = 3 #seconds
217 delay = 3 #seconds
247
218
248 nTries = 3 #quantity tries
219 nTries = 3 #quantity tries
249
220
250 nFiles = 3 #number of files for searching
221 nFiles = 3 #number of files for searching
222
251
223
252 nBlocks = 0
224 flagNoMoreFiles = 0
253
225
254 flagIsNewFile = 1
226 flagIsNewFile = 1
255
227
256 ippSeconds = 0
257
258 flagResetProcessing = 0
228 flagResetProcessing = 0
259
229
260 flagIsNewBlock = 0
230 flagIsNewBlock = 0
261
231
262 nReadBlocks = 0
232 def __init__(self):
263
233 pass
264 blocksize = 0
234
235 class JRODataReader(JRODataIO):
236
237 """
238 Esta clase es usada como la clase padre de las clases VoltageReader y SpectraReader.
239 Contiene todos lo metodos necesarios para leer datos desde archivos en formato
240 jicamarca o pdata (.r o .pdata). La lectura de los datos siempre se realiza por bloques. Los datos
241 leidos son array de 3 dimensiones:
265
242
266 datablockIndex = 9999
243 Para Voltajes - perfiles * alturas * canales
244
245 Para Spectra - paresCanalesIguales * alturas * perfiles (Self Spectra)
246 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
247 canales * alturas (DC Channels)
248
249 y son almacenados en su buffer respectivo.
250
251 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
252 RadarControllerHeader y DataObj. Los tres primeros se usan para almacenar informacion de la
253 cabecera de datos (metadata), y el cuarto (DataObj) para obtener y almacenar los datos desde
254 el buffer de datos cada vez que se ejecute el metodo "getData".
255 """
267
256
268 #speed of light
257 nReadBlocks = 0
269 c = 3E8
270
258
271 def __init__(self, m_DataObj=None):
259 def __init__(self, m_DataObj=None):
260
272 raise ValueError, "This class can't be instanced"
261 raise ValueError, "This class can't be instanced"
273
262
274
263
275
276
277
278 def hasNotDataInBuffer(self):
264 def hasNotDataInBuffer(self):
265
279 raise ValueError, "Not implemented"
266 raise ValueError, "Not implemented"
280
267
281
268 def getBlockDimension(self):
269
270 raise ValueError, "No implemented"
271
282 def readBlock(self):
272 def readBlock(self):
273
274 self.nTotalBlocks += 1
275 self.nReadBlocks += 1
276
283 raise ValueError, "This method has not been implemented"
277 raise ValueError, "This method has not been implemented"
284
278
285 def getData( self ):
279 def getData( self ):
280
286 raise ValueError, "This method has not been implemented"
281 raise ValueError, "This method has not been implemented"
282
287
283
288 def __rdSystemHeader(self, fp=None):
284 def __rdSystemHeader(self, fp=None):
289
285
@@ -313,9 +309,6 class JRODataReader(DataReader):
313 fp = self.fp
309 fp = self.fp
314
310
315 self.m_BasicHeader.read(fp)
311 self.m_BasicHeader.read(fp)
316
317 def getBlockDimension(self):
318 raise ValueError, "No implemented"
319
312
320 def __readFirstHeader(self):
313 def __readFirstHeader(self):
321 """
314 """
@@ -327,7 +320,6 class JRODataReader(DataReader):
327 self.m_RadarControllerHeader
320 self.m_RadarControllerHeader
328 self.m_ProcessingHeader
321 self.m_ProcessingHeader
329 self.firstHeaderSize
322 self.firstHeaderSize
330 self.heightList
331 self.dataType
323 self.dataType
332 self.fileSizeByHeader
324 self.fileSizeByHeader
333 self.ippSeconds
325 self.ippSeconds
@@ -341,40 +333,116 class JRODataReader(DataReader):
341 self.__rdProcessingHeader()
333 self.__rdProcessingHeader()
342 self.firstHeaderSize = self.m_BasicHeader.size
334 self.firstHeaderSize = self.m_BasicHeader.size
343
335
344 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
336 datatype = int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
345 if data_type == 0:
337 if datatype == 0:
346 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
338 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
347
339
348 elif data_type == 1:
340 elif datatype == 1:
349 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
341 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
350
342
351 elif data_type == 2:
343 elif datatype == 2:
352 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
344 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
353
345
354 elif data_type == 3:
346 elif datatype == 3:
355 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
347 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
356
348
357 elif data_type == 4:
349 elif datatype == 4:
358 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
350 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
359
351
360 elif data_type == 5:
352 elif datatype == 5:
361 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
353 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
362
354
363 else:
355 else:
364 raise ValueError, 'Data type was not defined'
356 raise ValueError, 'Data type was not defined'
365
357
366 xi = self.m_ProcessingHeader.firstHeight
358 self.dataType = datatype_str
367 step = self.m_ProcessingHeader.deltaHeight
368 xf = xi + self.m_ProcessingHeader.numHeights*step
369
370 self.heightList = numpy.arange(xi, xf, step)
371 self.channelList = numpy.arange(self.m_SystemHeader.numChannels)
372 self.dataType = tmp
373 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
374 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
359 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
375
360
361 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
362
376 self.getBlockDimension()
363 self.getBlockDimension()
364
365 def __setNewBlock(self):
366 """
367 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
368
369 Affected:
370 self.m_BasicHeader
371 self.flagNoContinuousBlock
372 self.ns
373
374 Return:
375 0 : Si el file no tiene un Basic Header que pueda ser leido
376 1 : Si se pudo leer el Basic Header
377 """
378 if self.fp == None:
379 return 0
380
381 if self.flagIsNewFile:
382 return 1
383
384 self.lastUTTime = self.m_BasicHeader.utc
385
386 currentSize = self.fileSize - self.fp.tell()
387 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
388
389 #If there is enough data setting new data block
390 if ( currentSize >= neededSize ):
391 self.__rdBasicHeader()
392 return 1
393
394 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
395 if self.online and (self.nReadBlocks < self.m_ProcessingHeader.dataBlocksPerFile):
396
397 fpointer = self.fp.tell()
398
399 for nTries in range( self.nTries ):
400 #self.fp.close()
401
402 print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
403 time.sleep( self.delay )
404
405 #self.fp = open( self.filename, 'rb' )
406 #self.fp.seek( fpointer )
407
408 self.fileSize = os.path.getsize( self.filename )
409 currentSize = self.fileSize - fpointer
410
411 if ( currentSize >= neededSize ):
412 self.__rdBasicHeader()
413 return 1
414
415 #Setting new file
416 if not( self.setNextFile() ):
417 return 0
418
419 deltaTime = self.m_BasicHeader.utc - self.lastUTTime # check this
420
421 self.flagResetProcessing = 0
422
423 if deltaTime > self.maxTimeStep:
424 self.flagResetProcessing = 1
425
426 return 1
427
428 def readNextBlock(self):
429 """
430 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
431 mas bloques disponibles en el archivo actual salta al siguiente.
432
433 Affected:
434 self.lastUTTime
377
435
436 Return: None
437 """
438
439 if not(self.__setNewBlock()):
440 return 0
441
442 if not(self.readBlock()):
443 return 0
444
445 return 1
378
446
379 def __setNextFileOnline(self):
447 def __setNextFileOnline(self):
380 """
448 """
@@ -540,81 +608,14 class JRODataReader(DataReader):
540 newFile = self.__setNextFileOnline()
608 newFile = self.__setNextFileOnline()
541 else:
609 else:
542 newFile = self.__setNextFileOffline()
610 newFile = self.__setNextFileOffline()
543
544 if self.flagNoMoreFiles:
545 sys.exit(0)
546
611
547 if not(newFile):
612 if not(newFile):
548 return 0
613 return 0
549
614
550 self.__readFirstHeader()
615 self.__readFirstHeader()
551 self.nBlocks = 0
616 self.nReadBlocks = 0
552 return 1
617 return 1
553
554
555 def __setNewBlock(self):
556 """
557 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
558
618
559 Affected:
560 self.m_BasicHeader
561 self.flagNoContinuousBlock
562 self.ns
563
564 Return:
565 0 : Si el file no tiene un Basic Header que pueda ser leido
566 1 : Si se pudo leer el Basic Header
567 """
568 if self.fp == None:
569 return 0
570
571 if self.flagIsNewFile:
572 return 1
573
574 currentSize = self.fileSize - self.fp.tell()
575 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
576
577 #If there is enough data setting new data block
578 if ( currentSize >= neededSize ):
579 self.__rdBasicHeader()
580 return 1
581
582 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
583 elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
584 for nTries in range( self.nTries ):
585
586 fpointer = self.fp.tell()
587 self.fp.close()
588
589 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
590 time.sleep( self.delay )
591
592 self.fp = open( self.filename, 'rb' )
593 self.fp.seek( fpointer )
594
595 self.fileSize = os.path.getsize( self.filename )
596 currentSize = self.fileSize - self.fp.tell()
597 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
598
599 if ( currentSize >= neededSize ):
600 self.__rdBasicHeader()
601 return 1
602
603 #Setting new file
604 if not( self.setNextFile() ):
605 return 0
606
607 deltaTime = self.m_BasicHeader.utc - self.lastUTTime # check this
608
609 self.flagResetProcessing = 0
610
611 if deltaTime > self.maxTimeStep:
612 self.flagResetProcessing = 1
613 #self.nReadBlocks = 0
614
615 return 1
616
617
618 def __searchFilesOnLine(self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = None):
619 def __searchFilesOnLine(self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = None):
619 """
620 """
620 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
621 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
@@ -818,8 +819,16 class JRODataReader(DataReader):
818 return 0
819 return 0
819
820
820 return 1
821 return 1
821
822
822
823 def updateDataHeader(self):
824
825 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
826 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
827 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
828 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
829
830 self.m_DataObj.updateObjFromHeader()
831
823 def setup(self, path, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
832 def setup(self, path, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
824 """
833 """
825 setup configura los parametros de lectura de la clase DataReader.
834 setup configura los parametros de lectura de la clase DataReader.
@@ -923,88 +932,20 class JRODataReader(DataReader):
923 self.endDoy = endDateTime.timetuple().tm_yday
932 self.endDoy = endDateTime.timetuple().tm_yday
924 #call fillHeaderValues() - to Data Object
933 #call fillHeaderValues() - to Data Object
925
934
926 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
935 self.updateDataHeader()
927 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
928 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
929 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
930 self.m_DataObj.dataType = self.dataType
931
936
932 return 1
933
934
935 def readNextBlock(self):
936 """
937 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
938 mas bloques disponibles en el archivo actual salta al siguiente.
939
940 Affected:
941 self.lastUTTime
942
943 Return: None
944 """
945 if not(self.__setNewBlock()):
946 return 0
947
948 if not(self.readBlock()):
949 return 0
950
951 self.lastUTTime = self.m_BasicHeader.utc
952
953 return 1
937 return 1
954
938
955
939 class JRODataWriter(JRODataIO):
956 class JRODataWriter(DataWriter):
957
940
958 """
941 """
959 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
942 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
960 de los datos siempre se realiza por bloques.
943 de los datos siempre se realiza por bloques.
961 """
944 """
962
945
963 m_BasicHeader = BasicHeader()
964
965 m_SystemHeader = SystemHeader()
966
967 m_RadarControllerHeader = RadarControllerHeader()
968
969 m_ProcessingHeader = ProcessingHeader()
970
971 fp = None
972
973 blocksCounter = 0
974
975 flagIsNewFile = 1
976
977 nWriteBlocks = 0
978
979 flagIsNewBlock = 0
980
981 flagNoMoreFiles = 0
982
983 m_DataObj = None
984
985 fp = None
986
987 blocksCounter = 0
988
989 flagIsNewFile = 1
990
991 nWriteBlocks = 0
946 nWriteBlocks = 0
992
993 flagIsNewBlock = 0
994
995 flagNoMoreFiles = 0
996
947
997 setFile = None
948 setFile = None
998
999 dataType = None
1000
1001 path = None
1002
1003 noMoreFiles = 0
1004
1005 filename = None
1006
1007 channelList = None
1008
949
1009
950
1010 def __init__(self, m_DataObj=None):
951 def __init__(self, m_DataObj=None):
@@ -1120,12 +1061,12 class JRODataWriter(DataWriter):
1120 timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc )
1061 timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc )
1121 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1062 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1122
1063
1123 tmp = os.path.join( path, subfolder )
1064 doypath = os.path.join( path, subfolder )
1124 if not( os.path.exists(tmp) ):
1065 if not( os.path.exists(doypath) ):
1125 os.mkdir(tmp)
1066 os.mkdir(doypath)
1126 self.setFile = -1 #inicializo mi contador de seteo
1067 self.setFile = -1 #inicializo mi contador de seteo
1127 else:
1068 else:
1128 filesList = os.listdir( tmp )
1069 filesList = os.listdir( doypath )
1129 if len( filesList ) > 0:
1070 if len( filesList ) > 0:
1130 filesList = sorted( filesList, key=str.lower )
1071 filesList = sorted( filesList, key=str.lower )
1131 filen = filesList[-1]
1072 filen = filesList[-1]
@@ -1152,7 +1093,7 class JRODataWriter(DataWriter):
1152
1093
1153 fp = open( filename,'wb' )
1094 fp = open( filename,'wb' )
1154
1095
1155 self.blocksCounter = 0
1096 self.nWriteBlocks = 0
1156
1097
1157 #guardando atributos
1098 #guardando atributos
1158 self.filename = filename
1099 self.filename = filename
@@ -1182,7 +1123,7 class JRODataWriter(DataWriter):
1182 if self.flagIsNewFile:
1123 if self.flagIsNewFile:
1183 return 1
1124 return 1
1184
1125
1185 if self.blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1126 if self.nWriteBlocks < self.m_ProcessingHeader.dataBlocksPerFile:
1186 self.__writeBasicHeader()
1127 self.__writeBasicHeader()
1187 return 1
1128 return 1
1188
1129
@@ -1208,7 +1149,7 class JRODataWriter(DataWriter):
1208 return 1
1149 return 1
1209
1150
1210
1151
1211 def getHeader(self):
1152 def getDataHeader(self):
1212 """
1153 """
1213 Obtiene una copia del First Header
1154 Obtiene una copia del First Header
1214
1155
@@ -1222,12 +1163,15 class JRODataWriter(DataWriter):
1222 Return:
1163 Return:
1223 None
1164 None
1224 """
1165 """
1166 self.m_DataObj.updateHeaderFromObj()
1167
1225 self.m_BasicHeader = self.m_DataObj.m_BasicHeader.copy()
1168 self.m_BasicHeader = self.m_DataObj.m_BasicHeader.copy()
1226 self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy()
1169 self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy()
1227 self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy()
1170 self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy()
1228 self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy()
1171 self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy()
1172
1229 self.dataType = self.m_DataObj.dataType
1173 self.dataType = self.m_DataObj.dataType
1230
1174
1231
1175
1232 def setup(self, path, set=0, ext=None):
1176 def setup(self, path, set=0, ext=None):
1233 """
1177 """
@@ -1252,7 +1196,7 class JRODataWriter(DataWriter):
1252 self.setFile = set - 1
1196 self.setFile = set - 1
1253 self.ext = ext
1197 self.ext = ext
1254 #self.format = format
1198 #self.format = format
1255 self.getHeader()
1199 self.getDataHeader()
1256
1200
1257 self.setBlockDimension()
1201 self.setBlockDimension()
1258
1202
Show file before | Show file after | Hide comments
@@ -18,9 +18,9 sys.path.append(path)
18 from Model.JROHeader import *
18 from Model.JROHeader import *
19 from Model.Spectra import Spectra
19 from Model.Spectra import Spectra
20
20
21 from DataIO import JRODataReader
21 from JRODataIO import JRODataReader
22 from DataIO import JRODataWriter
22 from JRODataIO import JRODataWriter
23 from DataIO import isNumber
23 from JRODataIO import isNumber
24
24
25
25
26 class SpectraReader( JRODataReader ):
26 class SpectraReader( JRODataReader ):
@@ -160,7 +160,7 class SpectraReader( JRODataReader ):
160
160
161 self.nFiles = 3 #number of files for searching
161 self.nFiles = 3 #number of files for searching
162
162
163 self.nBlocks = 0
163 self.nReadBlocks = 0
164
164
165 self.flagIsNewFile = 1
165 self.flagIsNewFile = 1
166
166
@@ -170,7 +170,7 class SpectraReader( JRODataReader ):
170
170
171 self.flagIsNewBlock = 0
171 self.flagIsNewBlock = 0
172
172
173 self.nReadBlocks = 0
173 self.nTotalBlocks = 0
174
174
175 self.blocksize = 0
175 self.blocksize = 0
176
176
@@ -202,14 +202,14 class SpectraReader( JRODataReader ):
202 """
202 """
203 self.nChannels = 0
203 self.nChannels = 0
204 self.nPairs = 0
204 self.nPairs = 0
205 #self.pairList = []
205 self.pairList = []
206
206
207 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
207 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
208 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
208 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
209 self.nChannels = self.nChannels + 1 #par de canales iguales
209 self.nChannels = self.nChannels + 1 #par de canales iguales
210 else:
210 else:
211 self.nPairs = self.nPairs + 1 #par de canales diferentes
211 self.nPairs = self.nPairs + 1 #par de canales diferentes
212 #self.pairList.append( (self.m_ProcessingHeader.spectraComb[i], self.m_ProcessingHeader.spectraComb[i+1]) )
212 self.pairList.append( (self.m_ProcessingHeader.spectraComb[i], self.m_ProcessingHeader.spectraComb[i+1]) )
213
213
214 pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock
214 pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock
215
215
@@ -217,13 +217,8 class SpectraReader( JRODataReader ):
217 self.pts2read_CrossSpectra = int( self.nPairs * pts2read )
217 self.pts2read_CrossSpectra = int( self.nPairs * pts2read )
218 self.pts2read_DCchannels = int( self.m_SystemHeader.numChannels * self.m_ProcessingHeader.numHeights )
218 self.pts2read_DCchannels = int( self.m_SystemHeader.numChannels * self.m_ProcessingHeader.numHeights )
219
219
220 self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
220 self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
221
221
222 self.m_DataObj.nPoints = self.m_ProcessingHeader.profilesPerBlock
223 self.m_DataObj.nChannels = self.nChannels
224 self.m_DataObj.nPairs = self.nPairs
225
226 #self.pairList = tuple( self.pairList )
227 self.channelList = numpy.arange( self.nChannels )
222 self.channelList = numpy.arange( self.nChannels )
228
223
229
224
@@ -240,7 +235,7 class SpectraReader( JRODataReader ):
240 self.datablockIndex
235 self.datablockIndex
241 self.flagIsNewFile
236 self.flagIsNewFile
242 self.flagIsNewBlock
237 self.flagIsNewBlock
243 self.nReadBlocks
238 self.nTotalBlocks
244 self.data_spc
239 self.data_spc
245 self.data_cspc
240 self.data_cspc
246 self.data_dc
241 self.data_dc
@@ -254,25 +249,6 class SpectraReader( JRODataReader ):
254 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
249 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
255 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
250 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
256 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
251 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
257
258 if self.online:
259 if (spc.size + cspc.size + dc.size) != self.blocksize:
260 for nTries in range( self.nTries ):
261 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
262 time.sleep( self.delay )
263 self.fp.seek( fpointer )
264 fpointer = self.fp.tell()
265
266 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
267 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
268 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
269
270 if (spc.size + cspc.size + dc.size) == self.blocksize:
271 blockOk_flag = True
272 break
273
274 if not( blockOk_flag ):
275 return 0
276
252
277 try:
253 try:
278 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
254 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
@@ -304,8 +280,8 class SpectraReader( JRODataReader ):
304 self.flagIsNewFile = 0
280 self.flagIsNewFile = 0
305 self.flagIsNewBlock = 1
281 self.flagIsNewBlock = 1
306
282
283 self.nTotalBlocks += 1
307 self.nReadBlocks += 1
284 self.nReadBlocks += 1
308 self.nBlocks += 1
309
285
310 return 1
286 return 1
311
287
@@ -335,15 +311,9 class SpectraReader( JRODataReader ):
335 if self.__hasNotDataInBuffer():
311 if self.__hasNotDataInBuffer():
336
312
337 if not( self.readNextBlock() ):
313 if not( self.readNextBlock() ):
338 self.setNextFile()
339 return 0
314 return 0
340
315
341 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
316 self.updateDataHeader()
342 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
343 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
344 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
345 self.m_DataObj.heightList = self.heightList
346 self.m_DataObj.dataType = self.dataType
347
317
348 if self.flagNoMoreFiles == 1:
318 if self.flagNoMoreFiles == 1:
349 print 'Process finished'
319 print 'Process finished'
@@ -420,11 +390,11 class SpectraWriter(JRODataWriter):
420
390
421 self.fp = None
391 self.fp = None
422
392
423 self.blocksCounter = 0
393 self.nWriteBlocks = 0
424
394
425 self.flagIsNewFile = 1
395 self.flagIsNewFile = 1
426
396
427 self.nWriteBlocks = 0
397 self.nTotalBlocks = 0
428
398
429 self.flagIsNewBlock = 0
399 self.flagIsNewBlock = 0
430
400
@@ -486,8 +456,8 class SpectraWriter(JRODataWriter):
486 self.data_dc
456 self.data_dc
487 self.flagIsNewFile
457 self.flagIsNewFile
488 self.flagIsNewBlock
458 self.flagIsNewBlock
489 self.nWriteBlocks
459 self.nTotalBlocks
490 self.blocksCounter
460 self.nWriteBlocks
491
461
492 Return: None
462 Return: None
493 """
463 """
@@ -522,8 +492,8 class SpectraWriter(JRODataWriter):
522
492
523 self.flagIsNewFile = 0
493 self.flagIsNewFile = 0
524 self.flagIsNewBlock = 1
494 self.flagIsNewBlock = 1
495 self.nTotalBlocks += 1
525 self.nWriteBlocks += 1
496 self.nWriteBlocks += 1
526 self.blocksCounter += 1
527
497
528
498
529 def putData(self):
499 def putData(self):
@@ -556,7 +526,7 class SpectraWriter(JRODataWriter):
556
526
557 # #self.m_ProcessingHeader.dataBlocksPerFile)
527 # #self.m_ProcessingHeader.dataBlocksPerFile)
558 if self.hasAllDataInBuffer():
528 if self.hasAllDataInBuffer():
559 self.getHeader()
529 self.getDataHeader()
560 self.writeNextBlock()
530 self.writeNextBlock()
561
531
562 if self.flagNoMoreFiles:
532 if self.flagNoMoreFiles:
Show file before | Show file after | Hide comments
@@ -48,7 +48,7 class TestIO():
48 print 'jump'
48 print 'jump'
49
49
50 if self.voltageReaderObj.flagIsNewBlock:
50 if self.voltageReaderObj.flagIsNewBlock:
51 print 'Block No %04d, Time: %s'%(self.voltageReaderObj.nReadBlocks,
51 print 'Block No %04d, Time: %s'%(self.voltageReaderObj.nTotalBlocks,
52 datetime.datetime.fromtimestamp(self.voltageReaderObj.m_BasicHeader.utc))
52 datetime.datetime.fromtimestamp(self.voltageReaderObj.m_BasicHeader.utc))
53
53
54 # self.voltageWriterObj.putData()
54 # self.voltageWriterObj.putData()
Show file before | Show file after | Hide comments
@@ -17,8 +17,8 sys.path.append(path)
17 from Model.JROHeader import *
17 from Model.JROHeader import *
18 from Model.Voltage import Voltage
18 from Model.Voltage import Voltage
19
19
20 from IO.DataIO import JRODataReader
20 from IO.JRODataIO import JRODataReader
21 from IO.DataIO import JRODataWriter
21 from IO.JRODataIO import JRODataWriter
22
22
23
23
24 class VoltageReader(JRODataReader):
24 class VoltageReader(JRODataReader):
@@ -50,7 +50,7 class VoltageReader(JRODataReader):
50
50
51 #to get one profile
51 #to get one profile
52 profile = readerObj.getData()
52 profile = readerObj.getData()
53
53
54 #print the profile
54 #print the profile
55 print profile
55 print profile
56
56
@@ -63,13 +63,7 class VoltageReader(JRODataReader):
63 """
63 """
64 m_DataObj = None
64 m_DataObj = None
65
65
66 idProfile = 0
67
68 datablock = None
66 datablock = None
69
70 pts2read = 0
71
72 utc = 0
73
67
74 ext = ".r"
68 ext = ".r"
75
69
@@ -101,13 +95,9 class VoltageReader(JRODataReader):
101 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
95 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
102
96
103 self.m_DataObj = m_Voltage
97 self.m_DataObj = m_Voltage
104
105 self.idProfile = 0
106
98
107 self.datablock = None
99 self.datablock = None
108
100
109 self.pts2read = 0
110
111 self.utc = 0
101 self.utc = 0
112
102
113 self.ext = ".r"
103 self.ext = ".r"
@@ -160,7 +150,7 class VoltageReader(JRODataReader):
160
150
161 self.path = None
151 self.path = None
162
152
163 self.datablockIndex = 9999
153 self.profileIndex = 9999
164
154
165 self.delay = 3 #seconds
155 self.delay = 3 #seconds
166
156
@@ -168,7 +158,7 class VoltageReader(JRODataReader):
168
158
169 self.nFiles = 3 #number of files for searching
159 self.nFiles = 3 #number of files for searching
170
160
171 self.nBlocks = 0
161 self.nReadBlocks = 0
172
162
173 self.flagIsNewFile = 1
163 self.flagIsNewFile = 1
174
164
@@ -178,12 +168,12 class VoltageReader(JRODataReader):
178
168
179 self.flagIsNewBlock = 0
169 self.flagIsNewBlock = 0
180
170
181 self.nReadBlocks = 0
171 self.nTotalBlocks = 0
182
172
183 self.blocksize = 0
173 self.blocksize = 0
184
174
185 def __hasNotDataInBuffer(self):
175 def __hasNotDataInBuffer(self):
186 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
176 if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock:
187 return 1
177 return 1
188 return 0
178 return 0
189
179
@@ -193,15 +183,13 class VoltageReader(JRODataReader):
193 Obtiene la cantidad de puntos a leer por cada bloque de datos
183 Obtiene la cantidad de puntos a leer por cada bloque de datos
194
184
195 Affected:
185 Affected:
196 self.pts2read
197 self.blocksize
186 self.blocksize
198
187
199 Return:
188 Return:
200 None
189 None
201 """
190 """
202 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
191 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
203 self.blocksize = self.pts2read
192 self.blocksize = pts2read
204 self.m_DataObj.nProfiles = self.m_ProcessingHeader.profilesPerBlock
205
193
206
194
207 def readBlock(self):
195 def readBlock(self):
@@ -218,54 +206,34 class VoltageReader(JRODataReader):
218 None
206 None
219
207
220 Affected:
208 Affected:
221 self.datablockIndex
209 self.profileIndex
222 self.datablock
210 self.datablock
223 self.flagIsNewFile
211 self.flagIsNewFile
224 self.idProfile
225 self.flagIsNewBlock
212 self.flagIsNewBlock
226 self.nReadBlocks
213 self.nTotalBlocks
227
214
228 Exceptions:
215 Exceptions:
229 Si un bloque leido no es un bloque valido
216 Si un bloque leido no es un bloque valido
230 """
217 """
231 blockOk_flag = False
218
232 fpointer = self.fp.tell()
219 junk = numpy.fromfile( self.fp, self.dataType, self.blocksize )
233
234 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
235
236 if self.online:
237 if junk.size != self.blocksize:
238 for nTries in range( self.nTries ):
239 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
240 time.sleep( self.delay )
241 self.fp.seek( fpointer )
242 fpointer = self.fp.tell()
243
244 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
245
246 if junk.size == self.blocksize:
247 blockOk_flag = True
248 break
249
250 if not( blockOk_flag ):
251 return 0
252
220
253 try:
221 try:
254 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
222 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
255 except:
223 except:
256 print "Data file %s is invalid" % self.filename
224 print "The read block (%3d) has not enough data" %self.nReadBlocks
257 return 0
225 return 0
258
226
259 junk = numpy.transpose(junk, (2,0,1))
227 junk = numpy.transpose(junk, (2,0,1))
260 self.datablock = junk['real'] + junk['imag']*1j
228 self.datablock = junk['real'] + junk['imag']*1j
261
229
262 self.datablockIndex = 0
230 self.profileIndex = 0
231
263 self.flagIsNewFile = 0
232 self.flagIsNewFile = 0
264 self.idProfile = 0
265 self.flagIsNewBlock = 1
233 self.flagIsNewBlock = 1
266
234
235 self.nTotalBlocks += 1
267 self.nReadBlocks += 1
236 self.nReadBlocks += 1
268 self.nBlocks += 1
269
237
270 return 1
238 return 1
271
239
@@ -284,15 +252,13 class VoltageReader(JRODataReader):
284
252
285 Variables afectadas:
253 Variables afectadas:
286 self.m_DataObj
254 self.m_DataObj
287 self.datablockIndex
255 self.profileIndex
288 self.idProfile
289
256
290 Affected:
257 Affected:
291 self.m_DataObj
258 self.m_DataObj
292 self.datablockIndex
259 self.profileIndex
293 self.flagResetProcessing
260 self.flagResetProcessing
294 self.flagIsNewBlock
261 self.flagIsNewBlock
295 self.idProfile
296 """
262 """
297 if self.flagNoMoreFiles: return 0
263 if self.flagNoMoreFiles: return 0
298
264
@@ -302,15 +268,9 class VoltageReader(JRODataReader):
302 if self.__hasNotDataInBuffer():
268 if self.__hasNotDataInBuffer():
303
269
304 if not( self.readNextBlock() ):
270 if not( self.readNextBlock() ):
305 self.setNextFile()
306 return 0
271 return 0
307
272
308 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
273 self.updateDataHeader()
309 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
310 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
311 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
312 self.m_DataObj.heightList = self.heightList
313 self.m_DataObj.dataType = self.dataType
314
274
315 if self.flagNoMoreFiles == 1:
275 if self.flagNoMoreFiles == 1:
316 print 'Process finished'
276 print 'Process finished'
@@ -322,17 +282,15 class VoltageReader(JRODataReader):
322 self.m_DataObj.flagNoData = True
282 self.m_DataObj.flagNoData = True
323 return 0
283 return 0
324
284
325 time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
285 time = self.m_BasicHeader.utc + self.profileIndex * self.ippSeconds
326 self.m_DataObj.m_BasicHeader.utc = time
286 self.m_DataObj.m_BasicHeader.utc = time
327
287
328 self.m_DataObj.flagNoData = False
288 self.m_DataObj.flagNoData = False
329 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
289 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
330
290
331 self.m_DataObj.data = self.datablock[:,self.datablockIndex,:]
291 self.m_DataObj.data = self.datablock[:,self.profileIndex,:]
332 self.m_DataObj.idProfile = self.idProfile
333
292
334 self.datablockIndex += 1
293 self.profileIndex += 1
335 self.idProfile += 1
336
294
337 #call setData - to Data Object
295 #call setData - to Data Object
338
296
@@ -354,7 +312,7 class VoltageWriter( JRODataWriter ):
354
312
355 datablock = None
313 datablock = None
356
314
357 datablockIndex = 0
315 profileIndex = 0
358
316
359 shapeBuffer = None
317 shapeBuffer = None
360
318
@@ -378,7 +336,7 class VoltageWriter( JRODataWriter ):
378
336
379
337
380 def hasAllDataInBuffer(self):
338 def hasAllDataInBuffer(self):
381 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
339 if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock:
382 return 1
340 return 1
383 return 0
341 return 0
384
342
@@ -409,11 +367,11 class VoltageWriter( JRODataWriter ):
409 Escribe el buffer en el file designado
367 Escribe el buffer en el file designado
410
368
411 Affected:
369 Affected:
412 self.datablockIndex
370 self.profileIndex
413 self.flagIsNewFile
371 self.flagIsNewFile
414 self.flagIsNewBlock
372 self.flagIsNewBlock
415 self.nWriteBlocks
373 self.nTotalBlocks
416 self.blocksCounter
374 self.nWriteBlocks
417
375
418 Return: None
376 Return: None
419 """
377 """
@@ -429,11 +387,11 class VoltageWriter( JRODataWriter ):
429 data.tofile( self.fp )
387 data.tofile( self.fp )
430
388
431 self.datablock.fill(0)
389 self.datablock.fill(0)
432 self.datablockIndex = 0
390 self.profileIndex = 0
433 self.flagIsNewFile = 0
391 self.flagIsNewFile = 0
434 self.flagIsNewBlock = 1
392 self.flagIsNewBlock = 1
393 self.nTotalBlocks += 1
435 self.nWriteBlocks += 1
394 self.nWriteBlocks += 1
436 self.blocksCounter += 1
437
395
438
396
439 def putData(self):
397 def putData(self):
@@ -442,7 +400,7 class VoltageWriter( JRODataWriter ):
442
400
443 Affected:
401 Affected:
444 self.flagIsNewBlock
402 self.flagIsNewBlock
445 self.datablockIndex
403 self.profileIndex
446
404
447 Return:
405 Return:
448 0 : Si no hay data o no hay mas files que puedan escribirse
406 0 : Si no hay data o no hay mas files que puedan escribirse
@@ -456,16 +414,16 class VoltageWriter( JRODataWriter ):
456 if self.m_DataObj.flagResetProcessing:
414 if self.m_DataObj.flagResetProcessing:
457
415
458 self.datablock.fill(0)
416 self.datablock.fill(0)
459 self.datablockIndex = 0
417 self.profileIndex = 0
460 self.setNextFile()
418 self.setNextFile()
461
419
462 self.datablock[:,self.datablockIndex,:] = self.m_DataObj.data
420 self.datablock[:,self.profileIndex,:] = self.m_DataObj.data
463
421
464 self.datablockIndex += 1
422 self.profileIndex += 1
465
423
466 if self.hasAllDataInBuffer():
424 if self.hasAllDataInBuffer():
467 #if self.flagIsNewFile:
425 #if self.flagIsNewFile:
468 self.getHeader()
426 self.getDataHeader()
469 self.writeNextBlock()
427 self.writeNextBlock()
470
428
471 if self.flagNoMoreFiles:
429 if self.flagNoMoreFiles:
Show file before | Show file after | Hide comments
@@ -4,15 +4,55 Created on Feb 7, 2012
4 @author $Author$
4 @author $Author$
5 @version $Id$
5 @version $Id$
6 '''
6 '''
7 from JROData import JROData, Noise
8 from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
7
9
8 class Correlation(Data):
10 class Correlation(JROData):
9 '''
11 '''
10 classdocs
12 classdocs
11 '''
13 '''
12
14
13
15 data = None
16
17 nLags = None
18
19 lagsList = None
20
14 def __init__(self):
21 def __init__(self):
15 '''
22 '''
16 Constructor
23 Constructor
17 '''
24 '''
18 pass No newline at end of file
25
26 self.m_RadarControllerHeader = RadarControllerHeader()
27
28 self.m_ProcessingHeader = ProcessingHeader()
29
30 self.m_SystemHeader = SystemHeader()
31
32 self.m_BasicHeader = BasicHeader()
33
34 self.m_NoiseObj = Noise()
35
36 self.type = "Spectra"
37
38 self.dataType = None
39
40 self.nHeights = 0
41
42 self.nChannels = 0
43
44 self.channelList = None
45
46 self.heightList = None
47
48 self.flagNoData = True
49
50 self.flagResetProcessing = False
51
52
53 self.data = None
54
55 self.nLags = 0
56
57 self.lagsList = None
58 No newline at end of file
Show file before | Show file after | Hide comments
@@ -11,7 +11,6 class Data:
11 '''
11 '''
12 classdocs
12 classdocs
13 '''
13 '''
14 type = None
15
14
16 def __init__(self):
15 def __init__(self):
17 '''
16 '''
@@ -46,27 +45,59 class JROData(Data):
46 '''
45 '''
47 classdocs
46 classdocs
48 '''
47 '''
48
49 m_RadarControllerHeader = RadarControllerHeader()
49 m_RadarControllerHeader = RadarControllerHeader()
50
50 m_ProcessingHeader = ProcessingHeader()
51 m_ProcessingHeader = ProcessingHeader()
52
51 m_SystemHeader = SystemHeader()
53 m_SystemHeader = SystemHeader()
54
52 m_BasicHeader = BasicHeader()
55 m_BasicHeader = BasicHeader()
56
53 m_NoiseObj = Noise()
57 m_NoiseObj = Noise()
54
58
55 data = None
59 type = None
60
56 dataType = None
61 dataType = None
57
62
58 nProfiles = None
59 nHeights = None
63 nHeights = None
64
60 nChannels = None
65 nChannels = None
61
66
62 heightList = None
67 heightList = None
68
63 channelList = None
69 channelList = None
64
70
65 flagNoData = False
71 flagNoData = False
72
66 flagResetProcessing = False
73 flagResetProcessing = False
67
74
68 def __init__(self):
75 def __init__(self):
69 '''
76 '''
70 Constructor
77 Constructor
71 '''
78 '''
72 raise ValueError, "This class has not been implemented" No newline at end of file
79 raise ValueError, "This class has not been implemented"
80
81 def updateHeaderFromObj(self):
82
83 xi = self.heightList[0]
84 step = self.heightList[1] - self.heightList[0]
85
86 self.m_ProcessingHeader.firstHeight = xi
87 self.m_ProcessingHeader.deltaHeight = step
88
89 self.m_ProcessingHeader.numHeights = self.nHeights
90 self.m_SystemHeader.numChannels = self.nChannels
91
92 def updateObjFromHeader(self):
93
94 xi = self.m_ProcessingHeader.firstHeight
95 step = self.m_ProcessingHeader.deltaHeight
96 xf = xi + self.m_ProcessingHeader.numHeights*step
97
98 self.heightList = numpy.arange(xi, xf, step)
99 self.channelList = numpy.arange(self.m_SystemHeader.numChannels)
100
101 self.nHeights = len(self.heightList)
102 self.nChannels = len(self.channelList)
103 No newline at end of file
Show file before | Show file after | Hide comments
@@ -13,11 +13,18 class Spectra(JROData):
13 classdocs
13 classdocs
14 '''
14 '''
15
15
16 type = "Spectra"
17 data_spc = None
16 data_spc = None
17
18 data_cspc = None
18 data_cspc = None
19
19 data_dc = None
20 data_dc = None
20
21
22 nFFTPoints = None
23
24 nPairs = None
25
26 pairsList = None
27
21
28
22 def __init__(self):
29 def __init__(self):
23 '''
30 '''
@@ -32,29 +39,38 class Spectra(JROData):
32
39
33 self.m_BasicHeader = BasicHeader()
40 self.m_BasicHeader = BasicHeader()
34
41
35 m_NoiseObj = Noise()
42 self.m_NoiseObj = Noise()
36
43
37 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
44 self.type = "Spectra"
38 self.data_spc = None
39
45
40 self.data_cspc = None
46 self.dataType = None
41
47
42 self.data_dc = None
48 self.nHeights = 0
43
49
44 self.heightList = None
50 self.nChannels = 0
45
51
46 self.channelList = None
52 self.channelList = None
47
53
54 self.heightList = None
55
48 self.flagNoData = True
56 self.flagNoData = True
49
57
50 self.nProfiles = None
58 self.flagResetProcessing = False
59
51
60
52 self.nPoints = None
61 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
62 self.data_spc = None
53
63
54 self.dataType = None
64 self.data_cspc = None
55
65
56 self.flagResetProcessing = False
66 self.data_dc = None
67
68 self.nFFTPoints = None
57
69
58 self.nPairs = 0
70 self.nPairs = 0
59
71
60 self.nChannels = 0 No newline at end of file
72 self.pairsList = None
73
74
75
76 No newline at end of file
Show file before | Show file after | Hide comments
@@ -13,8 +13,10 class Voltage(JROData):
13 classdocs
13 classdocs
14 '''
14 '''
15
15
16 type = "Voltage"
17 data = None
16 data = None
17
18 nProfiles = None
19
18 profileIndex = None
20 profileIndex = None
19
21
20 def __init__(self):
22 def __init__(self):
@@ -22,28 +24,40 class Voltage(JROData):
22 Constructor
24 Constructor
23 '''
25 '''
24
26
25 self.m_RadarControllerHeader= RadarControllerHeader()
27 self.m_RadarControllerHeader = RadarControllerHeader()
26
28
27 self.m_ProcessingHeader= ProcessingHeader()
29 self.m_ProcessingHeader = ProcessingHeader()
28
30
29 self.m_SystemHeader= SystemHeader()
31 self.m_SystemHeader = SystemHeader()
30
32
31 self.m_BasicHeader= BasicHeader()
33 self.m_BasicHeader = BasicHeader()
32
34
33 m_NoiseObj = Noise()
35 self.m_NoiseObj = Noise()
36
37 self.type = "Voltage"
34
38
35 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
39 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
36 self.data = None
40 self.data = None
37
41
38 self.dataType = None
42 self.dataType = None
39
43
44 self.nHeights = 0
45
46 self.nChannels = 0
47
48 self.channelList = None
49
40 self.heightList = None
50 self.heightList = None
41
51
52 self.flagNoData = True
53
54 self.flagResetProcessing = False
55
56
57
42 self.profileIndex = None
58 self.profileIndex = None
43
59
44 self.nProfiles = None
60 self.nProfiles = None
45
61
46 self.flagNoData = True
47
62
48 self.flagResetProcessing = False
49 No newline at end of file
63
Show file before | Show file after | Hide comments
@@ -52,7 +52,7 class SpectraProcessor:
52 self.plotterIndex = 0
52 self.plotterIndex = 0
53
53
54 if nFFTPoints == None:
54 if nFFTPoints == None:
55 nFFTPoints = self.dataOutObj.nPoints
55 nFFTPoints = self.dataOutObj.nFFTPoints
56
56
57 self.nFFTPoints = nFFTPoints
57 self.nFFTPoints = nFFTPoints
58 self.pairList = pairList
58 self.pairList = pairList
@@ -91,16 +91,16 class SpectraProcessor:
91 self.dataOutObj.m_ProcessingHeader.shif_fft
91 self.dataOutObj.m_ProcessingHeader.shif_fft
92 """
92 """
93 blocksize = 0
93 blocksize = 0
94 npoints = self.nFFTPoints
94 nFFTPoints = self.nFFTPoints
95 nchannels, nheis = self.dataInObj.data.shape
95 nChannels, nheis = self.dataInObj.data.shape
96
96
97 if self.buffer == None:
97 if self.buffer == None:
98 self.buffer = numpy.zeros((nchannels, npoints, nheis), dtype='complex')
98 self.buffer = numpy.zeros((nChannels, nFFTPoints, nheis), dtype='complex')
99
99
100 self.buffer[:,self.ptsId,:] = self.dataInObj.data
100 self.buffer[:,self.ptsId,:] = self.dataInObj.data
101 self.ptsId += 1
101 self.ptsId += 1
102
102
103 if self.ptsId < self.dataOutObj.nPoints:
103 if self.ptsId < self.dataOutObj.nFFTPoints:
104 self.dataOutObj.flagNoData = True
104 self.dataOutObj.flagNoData = True
105 return
105 return
106
106
@@ -115,14 +115,14 class SpectraProcessor:
115 blocksize += spc.size
115 blocksize += spc.size
116
116
117 cspc = None
117 cspc = None
118 npair = 0
118 nPair = 0
119 if self.pairList != None:
119 if self.pairList != None:
120 #calculo de cross-spectra
120 #calculo de cross-spectra
121 npairs = len(self.pairList)
121 nPairs = len(self.pairList)
122 cspc = numpy.zeros((npairs, npoints, nheis), dtype='complex')
122 cspc = numpy.zeros((nPairs, nFFTPoints, nheis), dtype='complex')
123 for pair in self.pairList:
123 for pair in self.pairList:
124 cspc[npair,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
124 cspc[nPair,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
125 npair += 1
125 nPair += 1
126 blocksize += cspc.size
126 blocksize += cspc.size
127
127
128 self.dataOutObj.data_spc = spc
128 self.dataOutObj.data_spc = spc
@@ -141,25 +141,25 class SpectraProcessor:
141 self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
141 self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
142
142
143 self.dataOutObj.dataType = self.dataInObj.dataType
143 self.dataOutObj.dataType = self.dataInObj.dataType
144 self.dataOutObj.nPairs = npair
144 self.dataOutObj.nPairs = nPair
145 self.dataOutObj.nChannels = nchannels
145 self.dataOutObj.nChannels = nChannels
146 self.dataOutObj.nProfiles = npoints
146 self.dataOutObj.nProfiles = nFFTPoints
147 self.dataOutObj.nHeights = nheis
147 self.dataOutObj.nHeights = nheis
148 self.dataOutObj.nPoints = npoints
148 self.dataOutObj.nFFTPoints = nFFTPoints
149 #self.dataOutObj.data = None
149 #self.dataOutObj.data = None
150
150
151 self.dataOutObj.m_SystemHeader.numChannels = nchannels
151 self.dataOutObj.m_SystemHeader.numChannels = nChannels
152 self.dataOutObj.m_SystemHeader.nProfiles = npoints
152 self.dataOutObj.m_SystemHeader.nProfiles = nFFTPoints
153
153
154 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
154 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
155 self.dataOutObj.m_ProcessingHeader.totalSpectra = nchannels + npair
155 self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPair
156 self.dataOutObj.m_ProcessingHeader.profilesPerBlock = npoints
156 self.dataOutObj.m_ProcessingHeader.profilesPerBlock = nFFTPoints
157 self.dataOutObj.m_ProcessingHeader.numHeights = nheis
157 self.dataOutObj.m_ProcessingHeader.numHeights = nheis
158 self.dataOutObj.m_ProcessingHeader.shif_fft = True
158 self.dataOutObj.m_ProcessingHeader.shif_fft = True
159
159
160 spectraComb = numpy.zeros( (nchannels+npair)*2,numpy.dtype('u1'))
160 spectraComb = numpy.zeros( (nChannels+nPair)*2,numpy.dtype('u1'))
161 k = 0
161 k = 0
162 for i in range( 0,nchannels*2,2 ):
162 for i in range( 0,nChannels*2,2 ):
163 spectraComb[i] = k
163 spectraComb[i] = k
164 spectraComb[i+1] = k
164 spectraComb[i+1] = k
165 k += 1
165 k += 1
@@ -285,29 +285,27 class SpectraProcessor:
285 if self.dataOutObj.flagNoData:
285 if self.dataOutObj.flagNoData:
286 return 0
286 return 0
287
287
288 nchannels = 0
288 nProfiles = self.dataOutObj.nProfiles
289 npairs = 0
290 profiles = self.dataOutObj.nProfiles
291 dataType = self.dataOutObj.dataType
289 dataType = self.dataOutObj.dataType
292 heights = self.dataOutObj.m_ProcessingHeader.numHeights
290 nHeights = self.dataOutObj.m_ProcessingHeader.numHeights
293 blocksize = 0
291 blocksize = 0
294
292
295 #self spectra
293 #self spectra
296 nchannels = len(channelList)
294 nChannels = len(channelList)
297 spc = numpy.zeros( (nchannels,profiles,heights), dataType[0] )
295 spc = numpy.zeros( (nChannels,nProfiles,nHeights), dataType[0] )
298
296
299 for index, channel in enumerate(channelList):
297 for index, channel in enumerate(channelList):
300 spc[index,:,:] = self.dataOutObj.data_spc[channel,:,:]
298 spc[index,:,:] = self.dataOutObj.data_spc[channel,:,:]
301
299
302 #DC channel
300 #DC channel
303 dc = numpy.zeros( (nchannels,heights), dtype='complex' )
301 dc = numpy.zeros( (nChannels,nHeights), dtype='complex' )
304 for index, channel in enumerate(channelList):
302 for index, channel in enumerate(channelList):
305 dc[index,:] = self.dataOutObj.data_dc[channel,:]
303 dc[index,:] = self.dataOutObj.data_dc[channel,:]
306
304
307 blocksize += dc.size
305 blocksize += dc.size
308 blocksize += spc.size
306 blocksize += spc.size
309
307
310 npairs = 0
308 nPairs = 0
311 cspc = None
309 cspc = None
312
310
313 if pairList == None:
311 if pairList == None:
@@ -315,8 +313,8 class SpectraProcessor:
315
313
316 if pairList != None:
314 if pairList != None:
317 #cross spectra
315 #cross spectra
318 npairs = len(pairList)
316 nPairs = len(pairList)
319 cspc = numpy.zeros( (npairs,profiles,heights), dtype='complex' )
317 cspc = numpy.zeros( (nPairs,nProfiles,nHeights), dtype='complex' )
320
318
321 spectraComb = self.dataOutObj.m_ProcessingHeader.spectraComb
319 spectraComb = self.dataOutObj.m_ProcessingHeader.spectraComb
322 totalSpectra = len(spectraComb)
320 totalSpectra = len(spectraComb)
@@ -338,7 +336,7 class SpectraProcessor:
338 if cspc != None:
336 if cspc != None:
339 blocksize += cspc.size
337 blocksize += cspc.size
340
338
341 spectraComb = numpy.zeros( (nchannels+npairs)*2,numpy.dtype('u1'))
339 spectraComb = numpy.zeros( (nChannels+nPairs)*2,numpy.dtype('u1'))
342 i = 0
340 i = 0
343 for val in channelList:
341 for val in channelList:
344 spectraComb[i] = val
342 spectraComb[i] = val
@@ -354,15 +352,15 class SpectraProcessor:
354 self.dataOutObj.data_spc = spc
352 self.dataOutObj.data_spc = spc
355 self.dataOutObj.data_cspc = cspc
353 self.dataOutObj.data_cspc = cspc
356 self.dataOutObj.data_dc = dc
354 self.dataOutObj.data_dc = dc
357 self.dataOutObj.nChannels = nchannels
355 self.dataOutObj.nChannels = nChannels
358 self.dataOutObj.nPairs = npairs
356 self.dataOutObj.nPairs = nPairs
359
357
360 self.dataOutObj.channelList = channelList
358 self.dataOutObj.channelList = channelList
361
359
362 self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
360 self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
363 self.dataOutObj.m_ProcessingHeader.totalSpectra = nchannels + npairs
361 self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPairs
364 self.dataOutObj.m_SystemHeader.numChannels = nchannels
362 self.dataOutObj.m_SystemHeader.numChannels = nChannels
365 self.dataOutObj.nChannels = nchannels
363 self.dataOutObj.nChannels = nChannels
366 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
364 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
367
365
368
366
@@ -432,26 +430,26 class SpectraProcessor:
432 if self.dataOutObj.flagNoData:
430 if self.dataOutObj.flagNoData:
433 return 0
431 return 0
434
432
435 nchannels = self.dataOutObj.nChannels
433 nChannels = self.dataOutObj.nChannels
436 npairs = self.dataOutObj.nPairs
434 nPairs = self.dataOutObj.nPairs
437 profiles = self.dataOutObj.nProfiles
435 nProfiles = self.dataOutObj.nProfiles
438 dataType = self.dataOutObj.dataType
436 dataType = self.dataOutObj.dataType
439 newheis = maxIndex - minIndex + 1
437 newheis = maxIndex - minIndex + 1
440 blockSize = 0
438 blockSize = 0
441
439
442 #self spectra
440 #self spectra
443 spc = numpy.zeros( (nchannels,profiles,newheis), dataType[0] )
441 spc = numpy.zeros( (nChannels,nProfiles,newheis), dataType[0] )
444 for i in range(nchannels):
442 for i in range(nChannels):
445 spc[i,:,:] = self.dataOutObj.data_spc[i,:,minIndex:maxIndex+1]
443 spc[i,:,:] = self.dataOutObj.data_spc[i,:,minIndex:maxIndex+1]
446
444
447 #cross spectra
445 #cross spectra
448 cspc = numpy.zeros( (npairs,profiles,newheis), dtype='complex')
446 cspc = numpy.zeros( (nPairs,nProfiles,newheis), dtype='complex')
449 for i in range(npairs):
447 for i in range(nPairs):
450 cspc[i,:,:] = self.dataOutObj.data_cspc[i,:,minIndex:maxIndex+1]
448 cspc[i,:,:] = self.dataOutObj.data_cspc[i,:,minIndex:maxIndex+1]
451
449
452 #DC channel
450 #DC channel
453 dc = numpy.zeros( (nchannels,newheis), dtype='complex')
451 dc = numpy.zeros( (nChannels,newheis), dtype='complex')
454 for i in range(nchannels):
452 for i in range(nChannels):
455 dc[i] = self.dataOutObj.data_dc[i,minIndex:maxIndex+1]
453 dc[i] = self.dataOutObj.data_dc[i,minIndex:maxIndex+1]
456
454
457 self.dataOutObj.data_spc = spc
455 self.dataOutObj.data_spc = spc
Show file before | Show file after | Hide comments
@@ -57,8 +57,8 class TestSChain():
57 if self.readerObj.noMoreFiles:
57 if self.readerObj.noMoreFiles:
58 break
58 break
59
59
60 if self.readerObj.flagIsNewBlock and self.readerObj.nReadBlocks:
60 if self.readerObj.flagIsNewBlock and self.readerObj.nTotalBlocks:
61 print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
61 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
62 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
62 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
63 #===============================================================
63 #===============================================================
64 # fin = time.time()
64 # fin = time.time()
Show file before | Show file after | Hide comments
@@ -85,7 +85,7 class TestSChain():
85 break
85 break
86
86
87 if self.readerObj.flagIsNewBlock:
87 if self.readerObj.flagIsNewBlock:
88 print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
88 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
89 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
89 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
90 fin = time.time()
90 fin = time.time()
91 print 'Tiempo de un bloque leido y escrito: [%6.5f]' %(fin - ini)
91 print 'Tiempo de un bloque leido y escrito: [%6.5f]' %(fin - ini)
Show file before | Show file after | Hide comments
@@ -28,27 +28,27 class TestSChain():
28 def setValues( self ):
28 def setValues( self ):
29
29
30 self.path = "/home/dsuarez/Projects" #1
30 self.path = "/home/dsuarez/Projects" #1
31 #self.path = "/home/valentin/Tmp/VOLTAGE2" #2
31 self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING"
32 # self.startDateTime = datetime.datetime(2007,5,1,15,49,0)
32 # self.startDateTime = datetime.datetime(2007,5,1,15,49,0)
33 # self.endDateTime = datetime.datetime(2007,5,1,23,0,0)
33 # self.endDateTime = datetime.datetime(2007,5,1,23,0,0)
34
34
35 self.startDateTime = datetime.datetime(2011,10,4,0,0,0)
35 self.startDateTime = datetime.datetime(2011,10,4,0,0,0)
36 self.endDateTime = datetime.datetime(2011,10,4,0,20,0)
36 self.endDateTime = datetime.datetime(2011,10,4,0,20,0)
37 self.N = 2
37 self.N = 10
38 self.npts = 4
38 self.npts = 1024
39
39
40 def createObjects( self ):
40 def createObjects( self ):
41
41
42 self.Obj = Voltage()
42 self.voltObj1 = Voltage()
43 self.OutObj = Voltage()
43 self.voltObj2 = Voltage()
44 self.readerObj = VoltageReader(self.Obj)
44 self.specObj1 = Spectra()
45 self.procObj = VoltageProcessor(self.Obj, self.OutObj)
46
45
47 self.spectraObj = Spectra()
46 self.readerObj = VoltageReader(self.voltObj1)
48 self.specProcObj = SpectraProcessor(self.OutObj, self.spectraObj,self.npts)
47 self.voltProcObj = VoltageProcessor(self.voltObj1, self.voltObj2)
48 self.specProcObj = SpectraProcessor(self.voltObj2, self.specObj1)
49
49
50
50
51 #self.plotObj = Osciloscope(self.Obj)
51 #self.plotObj = Osciloscope(self.voltObj1)
52
52
53 if not(self.readerObj.setup( self.path, self.startDateTime, self.endDateTime, expLabel='', online =0) ):
53 if not(self.readerObj.setup( self.path, self.startDateTime, self.endDateTime, expLabel='', online =0) ):
54 sys.exit(0)
54 sys.exit(0)
@@ -62,33 +62,33 class TestSChain():
62 while(True):
62 while(True):
63 self.readerObj.getData()
63 self.readerObj.getData()
64
64
65 self.procObj.init()
65 self.voltProcObj.init()
66
66
67 self.procObj.plotData(idProfile = 1, type='power',winTitle='figura 1')
67 # self.voltProcObj.plotData(idProfile = 1, type='iq', ymin=-25000, ymax=25000, winTitle='sin decodificar')
68
68
69 self.procObj.decoder(type=0)
69 self.voltProcObj.decoder(type=0)
70
70
71 # self.procObj.plotData(idProfile = 1, type='iq', xmin=0, xmax=100,winTitle='figura 2')
71 # self.voltProcObj.plotData(idProfile = 1, type='iq', ymin=-70000, ymax=70000,winTitle='Decodificado')
72 #
72 #
73 # self.procObj.integrator(self.N)
73 self.voltProcObj.integrator(self.N)
74
74
75 self.procObj.plotData(idProfile = 1, type='power',winTitle='figura 3')
75 # self.voltProcObj.plotData(idProfile = 1, type='iq', ymin=-700000, ymax=700000,winTitle='figura 3')
76
76
77 self.specProcObj.init()
77 self.specProcObj.init(self.npts)
78
78
79 self.specProcObj.integrator(2)
79 self.specProcObj.integrator(2)
80
80
81 self.specProcObj.plotData(winTitle='Spectra 1', index=2)
81 self.specProcObj.plotData(winTitle='Spectra 1', index=0)
82
82
83 # if self.readerObj.getData():
83 # if self.readerObj.getData():
84 # self.plotObj.plotData(idProfile=0, type='power' )
84 # self.plotObj.plotData(idProfile=0, type='power' )
85 #
85 #
86 #
86 #
87 # if self.readerObj.flagNoMoreFiles:
87 if self.readerObj.flagNoMoreFiles:
88 # break
88 break
89 #
89 #
90 if self.readerObj.flagIsNewBlock:
90 if self.readerObj.flagIsNewBlock:
91 print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
91 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
92 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
92 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
93
93
94 # fin = time.time()
94 # fin = time.time()
Show file before | Show file after | Hide comments
@@ -56,8 +56,8 class TestSChain():
56 if self.readerObj.flagNoMoreFiles:
56 if self.readerObj.flagNoMoreFiles:
57 break
57 break
58
58
59 if self.readerObj.flagIsNewBlock and self.readerObj.nReadBlocks:
59 if self.readerObj.flagIsNewBlock and self.readerObj.nTotalBlocks:
60 print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
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.m_BasicHeader.utc),)
62 #===============================================================
62 #===============================================================
63 # fin = time.time()
63 # fin = time.time()
Show file before | Show file after | Hide comments
@@ -57,8 +57,8 class TestSChain():
57 if self.readerObj.flagNoMoreFiles:
57 if self.readerObj.flagNoMoreFiles:
58 break
58 break
59
59
60 if self.readerObj.flagIsNewBlock and self.readerObj.nReadBlocks:
60 if self.readerObj.flagIsNewBlock and self.readerObj.nTotalBlocks:
61 print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
61 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
62 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc))
62 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc))
63 #===============================================================
63 #===============================================================
64 # fin = time.time()
64 # fin = time.time()
General Comments 0
You need to be logged in to leave comments. Login now