##// 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 136 nChan, nX, nY = numpy.shape(data)
137 137
138 138 x = numpy.arange(nX)
139 y = self.m_Spectra.heights
139 y = self.m_Spectra.heightList
140 140
141 141 thisDatetime = datetime.datetime.fromtimestamp(self.m_Spectra.m_BasicHeader.utc)
142 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 9 from DataIO import DataWriter
10 10
11 11 class CorrelationReader(DataReader):
12
12 13 def __init__(self):
14
13 15 pass
14 16
15 17 class CorrelationWriter(DataWriter):
18
16 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 167 return None
168 168
169
170 class DataReader():
171
172 def __init__(self):
173 pass
174
175
176 class DataWriter():
177
178 def __init__(self):
179 pass
180
169 class JRODataIO():
181 170
182 class JRODataReader(DataReader):
183
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 """
171 #speed of light
172 c = 3E8
203 173
204 174 m_BasicHeader = BasicHeader()
205 175
@@ -211,14 +181,12 class JRODataReader(DataReader):
211 181
212 182 m_DataObj = None
213 183
214 heightList = None
215
216 channelList = None
217
218 184 online = 0
219 185
220 186 fp = None
221 187
188 dataType = None
189
222 190 fileSizeByHeader = None
223 191
224 192 filenameList = []
@@ -231,11 +199,11 class JRODataReader(DataReader):
231 199
232 200 basicHeaderSize = 24
233 201
234 dataType = None
202 nTotalBlocks = 0
203
204 ippSeconds = 0
235 205
236 maxTimeStep = 30
237
238 flagNoMoreFiles = 0
206 blocksize = 0
239 207
240 208 set = 0
241 209
@@ -243,47 +211,75 class JRODataReader(DataReader):
243 211
244 212 path = None
245 213
214 maxTimeStep = 30
215
216
246 217 delay = 3 #seconds
247 218
248 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 226 flagIsNewFile = 1
255
256 ippSeconds = 0
257
227
258 228 flagResetProcessing = 0
259 229
260 230 flagIsNewBlock = 0
261 231
262 nReadBlocks = 0
263
264 blocksize = 0
232 def __init__(self):
233 pass
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
269 c = 3E8
257 nReadBlocks = 0
270 258
271 259 def __init__(self, m_DataObj=None):
260
272 261 raise ValueError, "This class can't be instanced"
273 262
274 263
275
276
277
278 264 def hasNotDataInBuffer(self):
265
279 266 raise ValueError, "Not implemented"
280
281
267
268 def getBlockDimension(self):
269
270 raise ValueError, "No implemented"
271
282 272 def readBlock(self):
273
274 self.nTotalBlocks += 1
275 self.nReadBlocks += 1
276
283 277 raise ValueError, "This method has not been implemented"
284
278
285 279 def getData( self ):
280
286 281 raise ValueError, "This method has not been implemented"
282
287 283
288 284 def __rdSystemHeader(self, fp=None):
289 285
@@ -313,9 +309,6 class JRODataReader(DataReader):
313 309 fp = self.fp
314 310
315 311 self.m_BasicHeader.read(fp)
316
317 def getBlockDimension(self):
318 raise ValueError, "No implemented"
319 312
320 313 def __readFirstHeader(self):
321 314 """
@@ -327,7 +320,6 class JRODataReader(DataReader):
327 320 self.m_RadarControllerHeader
328 321 self.m_ProcessingHeader
329 322 self.firstHeaderSize
330 self.heightList
331 323 self.dataType
332 324 self.fileSizeByHeader
333 325 self.ippSeconds
@@ -341,40 +333,116 class JRODataReader(DataReader):
341 333 self.__rdProcessingHeader()
342 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))
345 if data_type == 0:
346 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
336 datatype = int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
337 if datatype == 0:
338 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
347 339
348 elif data_type == 1:
349 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
340 elif datatype == 1:
341 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
350 342
351 elif data_type == 2:
352 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
343 elif datatype == 2:
344 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
353 345
354 elif data_type == 3:
355 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
346 elif datatype == 3:
347 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
356 348
357 elif data_type == 4:
358 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
349 elif datatype == 4:
350 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
359 351
360 elif data_type == 5:
361 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
352 elif datatype == 5:
353 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
362 354
363 355 else:
364 356 raise ValueError, 'Data type was not defined'
365 357
366 xi = self.m_ProcessingHeader.firstHeight
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)
358 self.dataType = datatype_str
374 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 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 447 def __setNextFileOnline(self):
380 448 """
@@ -540,81 +608,14 class JRODataReader(DataReader):
540 608 newFile = self.__setNextFileOnline()
541 609 else:
542 610 newFile = self.__setNextFileOffline()
543
544 if self.flagNoMoreFiles:
545 sys.exit(0)
546 611
547 612 if not(newFile):
548 613 return 0
549 614
550 615 self.__readFirstHeader()
551 self.nBlocks = 0
616 self.nReadBlocks = 0
552 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 619 def __searchFilesOnLine(self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = None):
619 620 """
620 621 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
@@ -818,8 +819,16 class JRODataReader(DataReader):
818 819 return 0
819 820
820 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 832 def setup(self, path, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
824 833 """
825 834 setup configura los parametros de lectura de la clase DataReader.
@@ -923,88 +932,20 class JRODataReader(DataReader):
923 932 self.endDoy = endDateTime.timetuple().tm_yday
924 933 #call fillHeaderValues() - to Data Object
925 934
926 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
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
935 self.updateDataHeader()
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 937 return 1
954
955
956 class JRODataWriter(DataWriter):
938
939 class JRODataWriter(JRODataIO):
957 940
958 941 """
959 942 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
960 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 946 nWriteBlocks = 0
992
993 flagIsNewBlock = 0
994
995 flagNoMoreFiles = 0
996 947
997 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 951 def __init__(self, m_DataObj=None):
@@ -1120,12 +1061,12 class JRODataWriter(DataWriter):
1120 1061 timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc )
1121 1062 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1122 1063
1123 tmp = os.path.join( path, subfolder )
1124 if not( os.path.exists(tmp) ):
1125 os.mkdir(tmp)
1064 doypath = os.path.join( path, subfolder )
1065 if not( os.path.exists(doypath) ):
1066 os.mkdir(doypath)
1126 1067 self.setFile = -1 #inicializo mi contador de seteo
1127 1068 else:
1128 filesList = os.listdir( tmp )
1069 filesList = os.listdir( doypath )
1129 1070 if len( filesList ) > 0:
1130 1071 filesList = sorted( filesList, key=str.lower )
1131 1072 filen = filesList[-1]
@@ -1152,7 +1093,7 class JRODataWriter(DataWriter):
1152 1093
1153 1094 fp = open( filename,'wb' )
1154 1095
1155 self.blocksCounter = 0
1096 self.nWriteBlocks = 0
1156 1097
1157 1098 #guardando atributos
1158 1099 self.filename = filename
@@ -1182,7 +1123,7 class JRODataWriter(DataWriter):
1182 1123 if self.flagIsNewFile:
1183 1124 return 1
1184 1125
1185 if self.blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1126 if self.nWriteBlocks < self.m_ProcessingHeader.dataBlocksPerFile:
1186 1127 self.__writeBasicHeader()
1187 1128 return 1
1188 1129
@@ -1208,7 +1149,7 class JRODataWriter(DataWriter):
1208 1149 return 1
1209 1150
1210 1151
1211 def getHeader(self):
1152 def getDataHeader(self):
1212 1153 """
1213 1154 Obtiene una copia del First Header
1214 1155
@@ -1222,12 +1163,15 class JRODataWriter(DataWriter):
1222 1163 Return:
1223 1164 None
1224 1165 """
1166 self.m_DataObj.updateHeaderFromObj()
1167
1225 1168 self.m_BasicHeader = self.m_DataObj.m_BasicHeader.copy()
1226 1169 self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy()
1227 1170 self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy()
1228 1171 self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy()
1172
1229 1173 self.dataType = self.m_DataObj.dataType
1230
1174
1231 1175
1232 1176 def setup(self, path, set=0, ext=None):
1233 1177 """
@@ -1252,7 +1196,7 class JRODataWriter(DataWriter):
1252 1196 self.setFile = set - 1
1253 1197 self.ext = ext
1254 1198 #self.format = format
1255 self.getHeader()
1199 self.getDataHeader()
1256 1200
1257 1201 self.setBlockDimension()
1258 1202
Show file before | Show file after | Hide comments
@@ -18,9 +18,9 sys.path.append(path)
18 18 from Model.JROHeader import *
19 19 from Model.Spectra import Spectra
20 20
21 from DataIO import JRODataReader
22 from DataIO import JRODataWriter
23 from DataIO import isNumber
21 from JRODataIO import JRODataReader
22 from JRODataIO import JRODataWriter
23 from JRODataIO import isNumber
24 24
25 25
26 26 class SpectraReader( JRODataReader ):
@@ -160,7 +160,7 class SpectraReader( JRODataReader ):
160 160
161 161 self.nFiles = 3 #number of files for searching
162 162
163 self.nBlocks = 0
163 self.nReadBlocks = 0
164 164
165 165 self.flagIsNewFile = 1
166 166
@@ -170,7 +170,7 class SpectraReader( JRODataReader ):
170 170
171 171 self.flagIsNewBlock = 0
172 172
173 self.nReadBlocks = 0
173 self.nTotalBlocks = 0
174 174
175 175 self.blocksize = 0
176 176
@@ -202,14 +202,14 class SpectraReader( JRODataReader ):
202 202 """
203 203 self.nChannels = 0
204 204 self.nPairs = 0
205 #self.pairList = []
205 self.pairList = []
206 206
207 207 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
208 208 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
209 209 self.nChannels = self.nChannels + 1 #par de canales iguales
210 210 else:
211 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 214 pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock
215 215
@@ -217,13 +217,8 class SpectraReader( JRODataReader ):
217 217 self.pts2read_CrossSpectra = int( self.nPairs * pts2read )
218 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 222 self.channelList = numpy.arange( self.nChannels )
228 223
229 224
@@ -240,7 +235,7 class SpectraReader( JRODataReader ):
240 235 self.datablockIndex
241 236 self.flagIsNewFile
242 237 self.flagIsNewBlock
243 self.nReadBlocks
238 self.nTotalBlocks
244 239 self.data_spc
245 240 self.data_cspc
246 241 self.data_dc
@@ -254,25 +249,6 class SpectraReader( JRODataReader ):
254 249 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
255 250 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
256 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 253 try:
278 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 280 self.flagIsNewFile = 0
305 281 self.flagIsNewBlock = 1
306 282
283 self.nTotalBlocks += 1
307 284 self.nReadBlocks += 1
308 self.nBlocks += 1
309 285
310 286 return 1
311 287
@@ -335,15 +311,9 class SpectraReader( JRODataReader ):
335 311 if self.__hasNotDataInBuffer():
336 312
337 313 if not( self.readNextBlock() ):
338 self.setNextFile()
339 314 return 0
340 315
341 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
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
316 self.updateDataHeader()
347 317
348 318 if self.flagNoMoreFiles == 1:
349 319 print 'Process finished'
@@ -420,11 +390,11 class SpectraWriter(JRODataWriter):
420 390
421 391 self.fp = None
422 392
423 self.blocksCounter = 0
393 self.nWriteBlocks = 0
424 394
425 395 self.flagIsNewFile = 1
426 396
427 self.nWriteBlocks = 0
397 self.nTotalBlocks = 0
428 398
429 399 self.flagIsNewBlock = 0
430 400
@@ -486,8 +456,8 class SpectraWriter(JRODataWriter):
486 456 self.data_dc
487 457 self.flagIsNewFile
488 458 self.flagIsNewBlock
489 self.nWriteBlocks
490 self.blocksCounter
459 self.nTotalBlocks
460 self.nWriteBlocks
491 461
492 462 Return: None
493 463 """
@@ -522,8 +492,8 class SpectraWriter(JRODataWriter):
522 492
523 493 self.flagIsNewFile = 0
524 494 self.flagIsNewBlock = 1
495 self.nTotalBlocks += 1
525 496 self.nWriteBlocks += 1
526 self.blocksCounter += 1
527 497
528 498
529 499 def putData(self):
@@ -556,7 +526,7 class SpectraWriter(JRODataWriter):
556 526
557 527 # #self.m_ProcessingHeader.dataBlocksPerFile)
558 528 if self.hasAllDataInBuffer():
559 self.getHeader()
529 self.getDataHeader()
560 530 self.writeNextBlock()
561 531
562 532 if self.flagNoMoreFiles:
Show file before | Show file after | Hide comments
@@ -48,7 +48,7 class TestIO():
48 48 print 'jump'
49 49
50 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 52 datetime.datetime.fromtimestamp(self.voltageReaderObj.m_BasicHeader.utc))
53 53
54 54 # self.voltageWriterObj.putData()
Show file before | Show file after | Hide comments
@@ -17,8 +17,8 sys.path.append(path)
17 17 from Model.JROHeader import *
18 18 from Model.Voltage import Voltage
19 19
20 from IO.DataIO import JRODataReader
21 from IO.DataIO import JRODataWriter
20 from IO.JRODataIO import JRODataReader
21 from IO.JRODataIO import JRODataWriter
22 22
23 23
24 24 class VoltageReader(JRODataReader):
@@ -50,7 +50,7 class VoltageReader(JRODataReader):
50 50
51 51 #to get one profile
52 52 profile = readerObj.getData()
53
53
54 54 #print the profile
55 55 print profile
56 56
@@ -63,13 +63,7 class VoltageReader(JRODataReader):
63 63 """
64 64 m_DataObj = None
65 65
66 idProfile = 0
67
68 66 datablock = None
69
70 pts2read = 0
71
72 utc = 0
73 67
74 68 ext = ".r"
75 69
@@ -101,13 +95,9 class VoltageReader(JRODataReader):
101 95 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
102 96
103 97 self.m_DataObj = m_Voltage
104
105 self.idProfile = 0
106 98
107 99 self.datablock = None
108 100
109 self.pts2read = 0
110
111 101 self.utc = 0
112 102
113 103 self.ext = ".r"
@@ -160,7 +150,7 class VoltageReader(JRODataReader):
160 150
161 151 self.path = None
162 152
163 self.datablockIndex = 9999
153 self.profileIndex = 9999
164 154
165 155 self.delay = 3 #seconds
166 156
@@ -168,7 +158,7 class VoltageReader(JRODataReader):
168 158
169 159 self.nFiles = 3 #number of files for searching
170 160
171 self.nBlocks = 0
161 self.nReadBlocks = 0
172 162
173 163 self.flagIsNewFile = 1
174 164
@@ -178,12 +168,12 class VoltageReader(JRODataReader):
178 168
179 169 self.flagIsNewBlock = 0
180 170
181 self.nReadBlocks = 0
171 self.nTotalBlocks = 0
182 172
183 173 self.blocksize = 0
184 174
185 175 def __hasNotDataInBuffer(self):
186 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
176 if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock:
187 177 return 1
188 178 return 0
189 179
@@ -193,15 +183,13 class VoltageReader(JRODataReader):
193 183 Obtiene la cantidad de puntos a leer por cada bloque de datos
194 184
195 185 Affected:
196 self.pts2read
197 186 self.blocksize
198 187
199 188 Return:
200 189 None
201 190 """
202 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
203 self.blocksize = self.pts2read
204 self.m_DataObj.nProfiles = self.m_ProcessingHeader.profilesPerBlock
191 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
192 self.blocksize = pts2read
205 193
206 194
207 195 def readBlock(self):
@@ -218,54 +206,34 class VoltageReader(JRODataReader):
218 206 None
219 207
220 208 Affected:
221 self.datablockIndex
209 self.profileIndex
222 210 self.datablock
223 211 self.flagIsNewFile
224 self.idProfile
225 212 self.flagIsNewBlock
226 self.nReadBlocks
213 self.nTotalBlocks
227 214
228 215 Exceptions:
229 216 Si un bloque leido no es un bloque valido
230 217 """
231 blockOk_flag = False
232 fpointer = self.fp.tell()
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
218
219 junk = numpy.fromfile( self.fp, self.dataType, self.blocksize )
252 220
253 221 try:
254 222 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
255 223 except:
256 print "Data file %s is invalid" % self.filename
224 print "The read block (%3d) has not enough data" %self.nReadBlocks
257 225 return 0
258 226
259 227 junk = numpy.transpose(junk, (2,0,1))
260 228 self.datablock = junk['real'] + junk['imag']*1j
261 229
262 self.datablockIndex = 0
230 self.profileIndex = 0
231
263 232 self.flagIsNewFile = 0
264 self.idProfile = 0
265 233 self.flagIsNewBlock = 1
266 234
235 self.nTotalBlocks += 1
267 236 self.nReadBlocks += 1
268 self.nBlocks += 1
269 237
270 238 return 1
271 239
@@ -284,15 +252,13 class VoltageReader(JRODataReader):
284 252
285 253 Variables afectadas:
286 254 self.m_DataObj
287 self.datablockIndex
288 self.idProfile
255 self.profileIndex
289 256
290 257 Affected:
291 258 self.m_DataObj
292 self.datablockIndex
259 self.profileIndex
293 260 self.flagResetProcessing
294 261 self.flagIsNewBlock
295 self.idProfile
296 262 """
297 263 if self.flagNoMoreFiles: return 0
298 264
@@ -302,15 +268,9 class VoltageReader(JRODataReader):
302 268 if self.__hasNotDataInBuffer():
303 269
304 270 if not( self.readNextBlock() ):
305 self.setNextFile()
306 271 return 0
307 272
308 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
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
273 self.updateDataHeader()
314 274
315 275 if self.flagNoMoreFiles == 1:
316 276 print 'Process finished'
@@ -322,17 +282,15 class VoltageReader(JRODataReader):
322 282 self.m_DataObj.flagNoData = True
323 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 286 self.m_DataObj.m_BasicHeader.utc = time
327 287
328 288 self.m_DataObj.flagNoData = False
329 289 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
330 290
331 self.m_DataObj.data = self.datablock[:,self.datablockIndex,:]
332 self.m_DataObj.idProfile = self.idProfile
291 self.m_DataObj.data = self.datablock[:,self.profileIndex,:]
333 292
334 self.datablockIndex += 1
335 self.idProfile += 1
293 self.profileIndex += 1
336 294
337 295 #call setData - to Data Object
338 296
@@ -354,7 +312,7 class VoltageWriter( JRODataWriter ):
354 312
355 313 datablock = None
356 314
357 datablockIndex = 0
315 profileIndex = 0
358 316
359 317 shapeBuffer = None
360 318
@@ -378,7 +336,7 class VoltageWriter( JRODataWriter ):
378 336
379 337
380 338 def hasAllDataInBuffer(self):
381 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
339 if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock:
382 340 return 1
383 341 return 0
384 342
@@ -409,11 +367,11 class VoltageWriter( JRODataWriter ):
409 367 Escribe el buffer en el file designado
410 368
411 369 Affected:
412 self.datablockIndex
370 self.profileIndex
413 371 self.flagIsNewFile
414 372 self.flagIsNewBlock
415 self.nWriteBlocks
416 self.blocksCounter
373 self.nTotalBlocks
374 self.nWriteBlocks
417 375
418 376 Return: None
419 377 """
@@ -429,11 +387,11 class VoltageWriter( JRODataWriter ):
429 387 data.tofile( self.fp )
430 388
431 389 self.datablock.fill(0)
432 self.datablockIndex = 0
390 self.profileIndex = 0
433 391 self.flagIsNewFile = 0
434 392 self.flagIsNewBlock = 1
393 self.nTotalBlocks += 1
435 394 self.nWriteBlocks += 1
436 self.blocksCounter += 1
437 395
438 396
439 397 def putData(self):
@@ -442,7 +400,7 class VoltageWriter( JRODataWriter ):
442 400
443 401 Affected:
444 402 self.flagIsNewBlock
445 self.datablockIndex
403 self.profileIndex
446 404
447 405 Return:
448 406 0 : Si no hay data o no hay mas files que puedan escribirse
@@ -456,16 +414,16 class VoltageWriter( JRODataWriter ):
456 414 if self.m_DataObj.flagResetProcessing:
457 415
458 416 self.datablock.fill(0)
459 self.datablockIndex = 0
417 self.profileIndex = 0
460 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 424 if self.hasAllDataInBuffer():
467 425 #if self.flagIsNewFile:
468 self.getHeader()
426 self.getDataHeader()
469 427 self.writeNextBlock()
470 428
471 429 if self.flagNoMoreFiles:
Show file before | Show file after | Hide comments
@@ -4,15 +4,55 Created on Feb 7, 2012
4 4 @author $Author$
5 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 12 classdocs
11 13 '''
12
13
14
15 data = None
16
17 nLags = None
18
19 lagsList = None
20
14 21 def __init__(self):
15 22 '''
16 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 12 classdocs
13 13 '''
14 type = None
15 14
16 15 def __init__(self):
17 16 '''
@@ -46,27 +45,59 class JROData(Data):
46 45 '''
47 46 classdocs
48 47 '''
48
49 49 m_RadarControllerHeader = RadarControllerHeader()
50
50 51 m_ProcessingHeader = ProcessingHeader()
52
51 53 m_SystemHeader = SystemHeader()
54
52 55 m_BasicHeader = BasicHeader()
56
53 57 m_NoiseObj = Noise()
54 58
55 data = None
59 type = None
60
56 61 dataType = None
57
58 nProfiles = None
62
59 63 nHeights = None
64
60 65 nChannels = None
61 66
62 67 heightList = None
68
63 69 channelList = None
64 70
65 71 flagNoData = False
72
66 73 flagResetProcessing = False
67 74
68 75 def __init__(self):
69 76 '''
70 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 13 classdocs
14 14 '''
15 15
16 type = "Spectra"
17 16 data_spc = None
17
18 18 data_cspc = None
19
19 20 data_dc = None
20 21
22 nFFTPoints = None
23
24 nPairs = None
25
26 pairsList = None
27
21 28
22 29 def __init__(self):
23 30 '''
@@ -32,29 +39,38 class Spectra(JROData):
32 39
33 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)
38 self.data_spc = None
44 self.type = "Spectra"
39 45
40 self.data_cspc = None
46 self.dataType = None
41 47
42 self.data_dc = None
43
44 self.heightList = None
48 self.nHeights = 0
49
50 self.nChannels = 0
45 51
46 52 self.channelList = None
47 53
54 self.heightList = None
55
48 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 70 self.nPairs = 0
59
60 self.nChannels = 0 No newline at end of file
71
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 13 classdocs
14 14 '''
15 15
16 type = "Voltage"
17 16 data = None
17
18 nProfiles = None
19
18 20 profileIndex = None
19 21
20 22 def __init__(self):
@@ -22,28 +24,40 class Voltage(JROData):
22 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 39 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
36 40 self.data = None
37 41
38 42 self.dataType = None
39 43
44 self.nHeights = 0
45
46 self.nChannels = 0
47
48 self.channelList = None
49
40 50 self.heightList = None
41 51
52 self.flagNoData = True
53
54 self.flagResetProcessing = False
55
56
57
42 58 self.profileIndex = None
43 59
44 60 self.nProfiles = None
45 61
46 self.flagNoData = True
47 62
48 self.flagResetProcessing = False
49 63 No newline at end of file
Show file before | Show file after | Hide comments
@@ -52,7 +52,7 class SpectraProcessor:
52 52 self.plotterIndex = 0
53 53
54 54 if nFFTPoints == None:
55 nFFTPoints = self.dataOutObj.nPoints
55 nFFTPoints = self.dataOutObj.nFFTPoints
56 56
57 57 self.nFFTPoints = nFFTPoints
58 58 self.pairList = pairList
@@ -91,16 +91,16 class SpectraProcessor:
91 91 self.dataOutObj.m_ProcessingHeader.shif_fft
92 92 """
93 93 blocksize = 0
94 npoints = self.nFFTPoints
95 nchannels, nheis = self.dataInObj.data.shape
94 nFFTPoints = self.nFFTPoints
95 nChannels, nheis = self.dataInObj.data.shape
96 96
97 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 100 self.buffer[:,self.ptsId,:] = self.dataInObj.data
101 101 self.ptsId += 1
102 102
103 if self.ptsId < self.dataOutObj.nPoints:
103 if self.ptsId < self.dataOutObj.nFFTPoints:
104 104 self.dataOutObj.flagNoData = True
105 105 return
106 106
@@ -115,14 +115,14 class SpectraProcessor:
115 115 blocksize += spc.size
116 116
117 117 cspc = None
118 npair = 0
118 nPair = 0
119 119 if self.pairList != None:
120 120 #calculo de cross-spectra
121 npairs = len(self.pairList)
122 cspc = numpy.zeros((npairs, npoints, nheis), dtype='complex')
121 nPairs = len(self.pairList)
122 cspc = numpy.zeros((nPairs, nFFTPoints, nheis), dtype='complex')
123 123 for pair in self.pairList:
124 cspc[npair,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
125 npair += 1
124 cspc[nPair,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
125 nPair += 1
126 126 blocksize += cspc.size
127 127
128 128 self.dataOutObj.data_spc = spc
@@ -141,25 +141,25 class SpectraProcessor:
141 141 self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
142 142
143 143 self.dataOutObj.dataType = self.dataInObj.dataType
144 self.dataOutObj.nPairs = npair
145 self.dataOutObj.nChannels = nchannels
146 self.dataOutObj.nProfiles = npoints
144 self.dataOutObj.nPairs = nPair
145 self.dataOutObj.nChannels = nChannels
146 self.dataOutObj.nProfiles = nFFTPoints
147 147 self.dataOutObj.nHeights = nheis
148 self.dataOutObj.nPoints = npoints
148 self.dataOutObj.nFFTPoints = nFFTPoints
149 149 #self.dataOutObj.data = None
150 150
151 self.dataOutObj.m_SystemHeader.numChannels = nchannels
152 self.dataOutObj.m_SystemHeader.nProfiles = npoints
151 self.dataOutObj.m_SystemHeader.numChannels = nChannels
152 self.dataOutObj.m_SystemHeader.nProfiles = nFFTPoints
153 153
154 154 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
155 self.dataOutObj.m_ProcessingHeader.totalSpectra = nchannels + npair
156 self.dataOutObj.m_ProcessingHeader.profilesPerBlock = npoints
155 self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPair
156 self.dataOutObj.m_ProcessingHeader.profilesPerBlock = nFFTPoints
157 157 self.dataOutObj.m_ProcessingHeader.numHeights = nheis
158 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 161 k = 0
162 for i in range( 0,nchannels*2,2 ):
162 for i in range( 0,nChannels*2,2 ):
163 163 spectraComb[i] = k
164 164 spectraComb[i+1] = k
165 165 k += 1
@@ -285,29 +285,27 class SpectraProcessor:
285 285 if self.dataOutObj.flagNoData:
286 286 return 0
287 287
288 nchannels = 0
289 npairs = 0
290 profiles = self.dataOutObj.nProfiles
288 nProfiles = self.dataOutObj.nProfiles
291 289 dataType = self.dataOutObj.dataType
292 heights = self.dataOutObj.m_ProcessingHeader.numHeights
290 nHeights = self.dataOutObj.m_ProcessingHeader.numHeights
293 291 blocksize = 0
294 292
295 293 #self spectra
296 nchannels = len(channelList)
297 spc = numpy.zeros( (nchannels,profiles,heights), dataType[0] )
294 nChannels = len(channelList)
295 spc = numpy.zeros( (nChannels,nProfiles,nHeights), dataType[0] )
298 296
299 297 for index, channel in enumerate(channelList):
300 298 spc[index,:,:] = self.dataOutObj.data_spc[channel,:,:]
301 299
302 300 #DC channel
303 dc = numpy.zeros( (nchannels,heights), dtype='complex' )
301 dc = numpy.zeros( (nChannels,nHeights), dtype='complex' )
304 302 for index, channel in enumerate(channelList):
305 303 dc[index,:] = self.dataOutObj.data_dc[channel,:]
306 304
307 305 blocksize += dc.size
308 306 blocksize += spc.size
309 307
310 npairs = 0
308 nPairs = 0
311 309 cspc = None
312 310
313 311 if pairList == None:
@@ -315,8 +313,8 class SpectraProcessor:
315 313
316 314 if pairList != None:
317 315 #cross spectra
318 npairs = len(pairList)
319 cspc = numpy.zeros( (npairs,profiles,heights), dtype='complex' )
316 nPairs = len(pairList)
317 cspc = numpy.zeros( (nPairs,nProfiles,nHeights), dtype='complex' )
320 318
321 319 spectraComb = self.dataOutObj.m_ProcessingHeader.spectraComb
322 320 totalSpectra = len(spectraComb)
@@ -338,7 +336,7 class SpectraProcessor:
338 336 if cspc != None:
339 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 340 i = 0
343 341 for val in channelList:
344 342 spectraComb[i] = val
@@ -354,15 +352,15 class SpectraProcessor:
354 352 self.dataOutObj.data_spc = spc
355 353 self.dataOutObj.data_cspc = cspc
356 354 self.dataOutObj.data_dc = dc
357 self.dataOutObj.nChannels = nchannels
358 self.dataOutObj.nPairs = npairs
355 self.dataOutObj.nChannels = nChannels
356 self.dataOutObj.nPairs = nPairs
359 357
360 358 self.dataOutObj.channelList = channelList
361 359
362 360 self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
363 self.dataOutObj.m_ProcessingHeader.totalSpectra = nchannels + npairs
364 self.dataOutObj.m_SystemHeader.numChannels = nchannels
365 self.dataOutObj.nChannels = nchannels
361 self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPairs
362 self.dataOutObj.m_SystemHeader.numChannels = nChannels
363 self.dataOutObj.nChannels = nChannels
366 364 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
367 365
368 366
@@ -432,26 +430,26 class SpectraProcessor:
432 430 if self.dataOutObj.flagNoData:
433 431 return 0
434 432
435 nchannels = self.dataOutObj.nChannels
436 npairs = self.dataOutObj.nPairs
437 profiles = self.dataOutObj.nProfiles
433 nChannels = self.dataOutObj.nChannels
434 nPairs = self.dataOutObj.nPairs
435 nProfiles = self.dataOutObj.nProfiles
438 436 dataType = self.dataOutObj.dataType
439 437 newheis = maxIndex - minIndex + 1
440 438 blockSize = 0
441 439
442 440 #self spectra
443 spc = numpy.zeros( (nchannels,profiles,newheis), dataType[0] )
444 for i in range(nchannels):
441 spc = numpy.zeros( (nChannels,nProfiles,newheis), dataType[0] )
442 for i in range(nChannels):
445 443 spc[i,:,:] = self.dataOutObj.data_spc[i,:,minIndex:maxIndex+1]
446 444
447 445 #cross spectra
448 cspc = numpy.zeros( (npairs,profiles,newheis), dtype='complex')
449 for i in range(npairs):
446 cspc = numpy.zeros( (nPairs,nProfiles,newheis), dtype='complex')
447 for i in range(nPairs):
450 448 cspc[i,:,:] = self.dataOutObj.data_cspc[i,:,minIndex:maxIndex+1]
451 449
452 450 #DC channel
453 dc = numpy.zeros( (nchannels,newheis), dtype='complex')
454 for i in range(nchannels):
451 dc = numpy.zeros( (nChannels,newheis), dtype='complex')
452 for i in range(nChannels):
455 453 dc[i] = self.dataOutObj.data_dc[i,minIndex:maxIndex+1]
456 454
457 455 self.dataOutObj.data_spc = spc
Show file before | Show file after | Hide comments
@@ -57,8 +57,8 class TestSChain():
57 57 if self.readerObj.noMoreFiles:
58 58 break
59 59
60 if self.readerObj.flagIsNewBlock and self.readerObj.nReadBlocks:
61 print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
60 if self.readerObj.flagIsNewBlock and self.readerObj.nTotalBlocks:
61 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
62 62 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
63 63 #===============================================================
64 64 # fin = time.time()
Show file before | Show file after | Hide comments
@@ -85,7 +85,7 class TestSChain():
85 85 break
86 86
87 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 89 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
90 90 fin = time.time()
91 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 28 def setValues( self ):
29 29
30 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 32 # self.startDateTime = datetime.datetime(2007,5,1,15,49,0)
33 33 # self.endDateTime = datetime.datetime(2007,5,1,23,0,0)
34 34
35 35 self.startDateTime = datetime.datetime(2011,10,4,0,0,0)
36 36 self.endDateTime = datetime.datetime(2011,10,4,0,20,0)
37 self.N = 2
38 self.npts = 4
37 self.N = 10
38 self.npts = 1024
39 39
40 40 def createObjects( self ):
41 41
42 self.Obj = Voltage()
43 self.OutObj = Voltage()
44 self.readerObj = VoltageReader(self.Obj)
45 self.procObj = VoltageProcessor(self.Obj, self.OutObj)
42 self.voltObj1 = Voltage()
43 self.voltObj2 = Voltage()
44 self.specObj1 = Spectra()
46 45
47 self.spectraObj = Spectra()
48 self.specProcObj = SpectraProcessor(self.OutObj, self.spectraObj,self.npts)
46 self.readerObj = VoltageReader(self.voltObj1)
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 53 if not(self.readerObj.setup( self.path, self.startDateTime, self.endDateTime, expLabel='', online =0) ):
54 54 sys.exit(0)
@@ -62,33 +62,33 class TestSChain():
62 62 while(True):
63 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 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 83 # if self.readerObj.getData():
84 84 # self.plotObj.plotData(idProfile=0, type='power' )
85 85 #
86 86 #
87 # if self.readerObj.flagNoMoreFiles:
88 # break
87 if self.readerObj.flagNoMoreFiles:
88 break
89 89 #
90 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 92 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
93 93
94 94 # fin = time.time()
Show file before | Show file after | Hide comments
@@ -56,8 +56,8 class TestSChain():
56 56 if self.readerObj.flagNoMoreFiles:
57 57 break
58 58
59 if self.readerObj.flagIsNewBlock and self.readerObj.nReadBlocks:
60 print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
59 if self.readerObj.flagIsNewBlock and self.readerObj.nTotalBlocks:
60 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
61 61 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
62 62 #===============================================================
63 63 # fin = time.time()
Show file before | Show file after | Hide comments
@@ -57,8 +57,8 class TestSChain():
57 57 if self.readerObj.flagNoMoreFiles:
58 58 break
59 59
60 if self.readerObj.flagIsNewBlock and self.readerObj.nReadBlocks:
61 print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
60 if self.readerObj.flagIsNewBlock and self.readerObj.nTotalBlocks:
61 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
62 62 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc))
63 63 #===============================================================
64 64 # fin = time.time()
General Comments 0
You need to be logged in to leave comments. Login now