##// END OF EJS Templates
schain-jc
RSS
Changing the Model for the input Objects in Processing package...
Daniel Valdez -
r107:33fbc5472d1b
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,23 +1,13
1 [Read0]
1 [Read0]
2 id = 0
2 id = 0
3 type = VoltageReader
3 type = VoltageReader
4 setup = str,/Users/jro/Documents/RadarData/EW_Drifts,datetime,2011-11-20-0-0-1,datetime,2011-12-31-0-0-1,int,0,str,,str,None,int,0
4 setup = str,/Users/jro/Documents/RadarData/MST_ISR/MST,datetime,2009-01-01-0-0-1,datetime,2009-12-31-0-0-1,int,0,str,,str,None,int,0
5 getData = None,None
5 getData = None,None
6
6
7 [Processing0]
7 [Processing0]
8 id = 1
8 id = 1
9 type = Voltage
10 input = 0
11 setup = None,None
12 init = None,None
13 integrator = int,4,None,None
14 plotData = float,None,float,None,float,None,float,None,str,iq,str,Test Data Voltage 2,int,1
15
16 [Processing1]
17 id = 2
18 type = Spectra
9 type = Spectra
19 input = 1
10 input = 0
20 setup = int,8,None,None
11 setup = int,16,None,None
21 init = None,None
12 init = None,None
22 integrator = int,4,int,3
13 plotData = float,None,float,None,float,None,float,None,str,Test Spectra Data,int,1
23 plotData = float,None,float,None,float,None,float,None,str,Test Spectra Data,int,2
Show file before | Show file after | Hide comments
@@ -621,7 +621,7 class ColorPlot:
621
621
622
622
623
623
624 def plotData(self, data, x=None, y=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None):
624 def plotData(self, data, x=None, y=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, title = ''):
625 """
625 """
626 Inputs:
626 Inputs:
627
627
@@ -647,6 +647,7 class ColorPlot:
647
647
648 plplot.plschr(0.0, self.__szchar)
648 plplot.plschr(0.0, self.__szchar)
649 self.__iniSubpage()
649 self.__iniSubpage()
650 self.colorGraphObj.title = title
650 self.colorGraphObj.plotBox(xmin, xmax, ymin, ymax)
651 self.colorGraphObj.plotBox(xmin, xmax, ymin, ymax)
651 self.colorGraphObj.basicPcolorPlot(data, x, y, xmin, xmax, ymin, ymax, zmin, zmax)
652 self.colorGraphObj.basicPcolorPlot(data, x, y, xmin, xmax, ymin, ymax, zmin, zmax)
652
653
@@ -661,7 +662,7 class ColorPlot:
661 cmapObj.colorbarPlot(0., 1., zmin, zmax)
662 cmapObj.colorbarPlot(0., 1., zmin, zmax)
662
663
663 if self.__showPowerProfile:
664 if self.__showPowerProfile:
664 power = numpy.max(data, axis=0)
665 power = numpy.average(data, axis=0)
665
666
666 step = (ymax - ymin)/(nY-1)
667 step = (ymax - ymin)/(nY-1)
667 heis = numpy.arange(ymin, ymax + step, step)
668 heis = numpy.arange(ymin, ymax + step, step)
Show file before | Show file after | Hide comments
@@ -154,7 +154,7 class Spectrum:
154 plplot.plsstrm(self.indexPlot)
154 plplot.plsstrm(self.indexPlot)
155
155
156 data = 10.*numpy.log10(self.spectraObj.data_spc)
156 data = 10.*numpy.log10(self.spectraObj.data_spc)
157
157 noise = 10.*numpy.log10(self.spectraObj.noise)
158 #data.shape = Channels x Heights x Profiles
158 #data.shape = Channels x Heights x Profiles
159 # data = numpy.transpose( data, (0,2,1) )
159 # data = numpy.transpose( data, (0,2,1) )
160 #data.shape = Channels x Profiles x Heights
160 #data.shape = Channels x Profiles x Heights
@@ -186,7 +186,8 class Spectrum:
186 ymin=ymin,
186 ymin=ymin,
187 ymax=ymax,
187 ymax=ymax,
188 zmin=zmin,
188 zmin=zmin,
189 zmax=zmax)
189 zmax=zmax,
190 title = "Channel: %d - Noise: %.2f" %(i, noise[i]))
190
191
191 plplot.plssub(1,0)
192 plplot.plssub(1,0)
192 plplot.pladv(0)
193 plplot.pladv(0)
Show file before | Show file after | Hide comments
@@ -179,7 +179,7 class JRODataIO:
179
179
180 m_ProcessingHeader = ProcessingHeader()
180 m_ProcessingHeader = ProcessingHeader()
181
181
182 m_DataObj = None
182 dataOutObj = None
183
183
184 online = 0
184 online = 0
185
185
@@ -256,7 +256,7 class JRODataReader(JRODataIO):
256
256
257 nReadBlocks = 0
257 nReadBlocks = 0
258
258
259 def __init__(self, m_DataObj=None):
259 def __init__(self, dataOutObj=None):
260
260
261 raise ValueError, "This class can't be instanced"
261 raise ValueError, "This class can't be instanced"
262
262
@@ -280,6 +280,126 class JRODataReader(JRODataIO):
280
280
281 raise ValueError, "This method has not been implemented"
281 raise ValueError, "This method has not been implemented"
282
282
283 def createObjByDefault(self):
284 """
285 Los objetos creados por defecto por cada clase (Voltaje o Espectro) difieren en el tipo
286 raise ValueError, "This method has not been implemented
287 """
288 raise ValueError, "This method has not been implemented"
289
290 def setup(self, dataOutObj=None, path=None, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
291 """
292 setup configura los parametros de lectura de la clase DataReader.
293
294 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
295 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
296 self.filenameList.
297
298 Input:
299 path : Directorios donde se ubican los datos a leer. Dentro de este
300 directorio deberia de estar subdirectorios de la forma:
301
302 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
303
304 startDateTime : Fecha inicial. Rechaza todos los archivos donde
305 file end time < startDatetime (obejto datetime.datetime)
306
307 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
308 file end time < startDatetime (obejto datetime.datetime)
309
310 set : Set del primer archivo a leer. Por defecto None
311
312 expLabel : Nombre del subdirectorio de datos. Por defecto ""
313
314 ext : Extension de los archivos a leer. Por defecto .r
315
316 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
317
318 Return:
319 0 : Si no encuentra files que cumplan con las condiciones dadas
320 1 : Si encuentra files que cumplan con las condiciones dadas
321
322 Affected:
323 self.startUTCSeconds
324 self.endUTCSeconds
325 self.startYear
326 self.endYear
327 self.startDoy
328 self.endDoy
329 self.pathList
330 self.filenameList
331 self.online
332 """
333 if path == None:
334 raise ValueError, "The path is not valid"
335
336 if ext == None:
337 ext = self.ext
338
339 if dataOutObj == None:
340 dataOutObj = self.createObjByDefault()
341
342 self.dataOutObj = dataOutObj
343
344 if online:
345 print "Searching files ..."
346 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
347
348 if not(doypath):
349 for nTries in range( self.nTries ):
350 print '\tWaiting %0.2f sec for valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
351 time.sleep( self.delay )
352 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
353 if doypath:
354 break
355
356 if not(doypath):
357 print "There 'isn't valied files in %s" % path
358 return None
359
360 self.year = year
361 self.doy = doy
362 self.set = set - 1
363 self.path = path
364
365 else: # offline
366 pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext)
367 if not(pathList):
368 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
369 return None
370
371 self.fileIndex = -1
372 self.pathList = pathList
373 self.filenameList = filenameList
374
375 self.online = online
376 self.ext = ext
377
378 ext = ext.lower()
379
380 if not( self.setNextFile() ):
381 if (startDateTime != None) and (endDateTime != None):
382 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
383 elif startDateTime != None:
384 print "No files in : %s" % startDateTime.ctime()
385 else:
386 print "No files"
387 return None
388
389 if startDateTime != None:
390 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
391 self.startYear = startDateTime.timetuple().tm_year
392 self.startDoy = startDateTime.timetuple().tm_yday
393
394 if endDateTime != None:
395 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
396 self.endYear = endDateTime.timetuple().tm_year
397 self.endDoy = endDateTime.timetuple().tm_yday
398 #call fillHeaderValues() - to Data Object
399
400 self.updateDataHeader()
401
402 return self.dataOutObj
283
403
284 def __rdSystemHeader(self, fp=None):
404 def __rdSystemHeader(self, fp=None):
285
405
@@ -359,7 +479,9 class JRODataReader(JRODataIO):
359 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
479 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
360
480
361 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
481 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
362
482 self.dataOutObj.channelList = numpy.arange(self.m_SystemHeader.numChannels)
483 self.dataOutObj.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
484
363 self.getBlockDimension()
485 self.getBlockDimension()
364
486
365
487
@@ -833,120 +955,14 class JRODataReader(JRODataIO):
833
955
834 def updateDataHeader(self):
956 def updateDataHeader(self):
835
957
836 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
958 self.dataOutObj.m_BasicHeader = self.m_BasicHeader.copy()
837 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
959 self.dataOutObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
838 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
960 self.dataOutObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
839 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
961 self.dataOutObj.m_SystemHeader = self.m_SystemHeader.copy()
840
841 self.m_DataObj.dataType = self.dataType
842 self.m_DataObj.updateObjFromHeader()
843
844 def setup(self, path, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
845 """
846 setup configura los parametros de lectura de la clase DataReader.
847
848 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
849 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
850 self.filenameList.
851
852 Input:
853 path : Directorios donde se ubican los datos a leer. Dentro de este
854 directorio deberia de estar subdirectorios de la forma:
855
856 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
857
858 startDateTime : Fecha inicial. Rechaza todos los archivos donde
859 file end time < startDatetime (obejto datetime.datetime)
860
861 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
862 file end time < startDatetime (obejto datetime.datetime)
863
864 set : Set del primer archivo a leer. Por defecto None
865
866 expLabel : Nombre del subdirectorio de datos. Por defecto ""
867
868 ext : Extension de los archivos a leer. Por defecto .r
869
870 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
871
872 Return:
873 0 : Si no encuentra files que cumplan con las condiciones dadas
874 1 : Si encuentra files que cumplan con las condiciones dadas
875
876 Affected:
877 self.startUTCSeconds
878 self.endUTCSeconds
879 self.startYear
880 self.endYear
881 self.startDoy
882 self.endDoy
883 self.pathList
884 self.filenameList
885 self.online
886 """
887
962
888 if ext == None:
963 self.dataOutObj.dataType = self.dataType
889 ext = self.ext
964 self.dataOutObj.updateObjFromHeader()
890
891 if online:
892 print "Searching files ..."
893 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
894
965
895 if not(doypath):
896 for nTries in range( self.nTries ):
897 print '\tWaiting %0.2f sec for valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
898 time.sleep( self.delay )
899 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
900 if doypath:
901 break
902
903 if not(doypath):
904 print "There 'isn't valied files in %s" % path
905 return 0
906
907 self.year = year
908 self.doy = doy
909 self.set = set - 1
910 self.path = path
911
912 else: # offline
913 pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext)
914 if not(pathList):
915 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
916 return 0
917
918 self.fileIndex = -1
919 self.pathList = pathList
920 self.filenameList = filenameList
921
922 self.online = online
923 self.ext = ext
924
925 ext = ext.lower()
926
927 if not( self.setNextFile() ):
928 if (startDateTime != None) and (endDateTime != None):
929 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
930 elif startDateTime != None:
931 print "No files in : %s" % startDateTime.ctime()
932 else:
933 print "No files"
934 return 0
935
936 if startDateTime != None:
937 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
938 self.startYear = startDateTime.timetuple().tm_year
939 self.startDoy = startDateTime.timetuple().tm_yday
940
941 if endDateTime != None:
942 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
943 self.endYear = endDateTime.timetuple().tm_year
944 self.endDoy = endDateTime.timetuple().tm_yday
945 #call fillHeaderValues() - to Data Object
946
947 self.updateDataHeader()
948
949 return 1
950
966
951 class JRODataWriter(JRODataIO):
967 class JRODataWriter(JRODataIO):
952
968
@@ -960,7 +976,7 class JRODataWriter(JRODataIO):
960 setFile = None
976 setFile = None
961
977
962
978
963 def __init__(self, m_DataObj=None):
979 def __init__(self, dataOutObj=None):
964 raise ValueError, "Not implemented"
980 raise ValueError, "Not implemented"
965
981
966
982
@@ -994,7 +1010,7 class JRODataWriter(JRODataIO):
994 self.__wrSystemHeader()
1010 self.__wrSystemHeader()
995 self.__wrRadarControllerHeader()
1011 self.__wrRadarControllerHeader()
996 self.__wrProcessingHeader()
1012 self.__wrProcessingHeader()
997 self.dataType = self.m_DataObj.dataType
1013 self.dataType = self.dataOutObj.dataType
998
1014
999
1015
1000 def __writeBasicHeader(self, fp=None):
1016 def __writeBasicHeader(self, fp=None):
@@ -1007,7 +1023,7 class JRODataWriter(JRODataIO):
1007 if fp == None:
1023 if fp == None:
1008 fp = self.fp
1024 fp = self.fp
1009
1025
1010 self.m_DataObj.m_BasicHeader.write(fp)
1026 self.dataOutObj.m_BasicHeader.write(fp)
1011
1027
1012
1028
1013 def __wrSystemHeader(self, fp=None):
1029 def __wrSystemHeader(self, fp=None):
@@ -1020,7 +1036,7 class JRODataWriter(JRODataIO):
1020 if fp == None:
1036 if fp == None:
1021 fp = self.fp
1037 fp = self.fp
1022
1038
1023 self.m_DataObj.m_SystemHeader.write(fp)
1039 self.dataOutObj.m_SystemHeader.write(fp)
1024
1040
1025
1041
1026 def __wrRadarControllerHeader(self, fp=None):
1042 def __wrRadarControllerHeader(self, fp=None):
@@ -1033,7 +1049,7 class JRODataWriter(JRODataIO):
1033 if fp == None:
1049 if fp == None:
1034 fp = self.fp
1050 fp = self.fp
1035
1051
1036 self.m_DataObj.m_RadarControllerHeader.write(fp)
1052 self.dataOutObj.m_RadarControllerHeader.write(fp)
1037
1053
1038
1054
1039 def __wrProcessingHeader(self, fp=None):
1055 def __wrProcessingHeader(self, fp=None):
@@ -1046,7 +1062,7 class JRODataWriter(JRODataIO):
1046 if fp == None:
1062 if fp == None:
1047 fp = self.fp
1063 fp = self.fp
1048
1064
1049 self.m_DataObj.m_ProcessingHeader.write(fp)
1065 self.dataOutObj.m_ProcessingHeader.write(fp)
1050
1066
1051
1067
1052 def setNextFile(self):
1068 def setNextFile(self):
@@ -1070,7 +1086,7 class JRODataWriter(JRODataIO):
1070 if self.fp != None:
1086 if self.fp != None:
1071 self.fp.close()
1087 self.fp.close()
1072
1088
1073 timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc )
1089 timeTuple = time.localtime( self.dataOutObj.m_BasicHeader.utc )
1074 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1090 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1075
1091
1076 doypath = os.path.join( path, subfolder )
1092 doypath = os.path.join( path, subfolder )
@@ -1175,14 +1191,14 class JRODataWriter(JRODataIO):
1175 Return:
1191 Return:
1176 None
1192 None
1177 """
1193 """
1178 self.m_DataObj.updateHeaderFromObj()
1194 self.dataOutObj.updateHeaderFromObj()
1179
1195
1180 self.m_BasicHeader = self.m_DataObj.m_BasicHeader.copy()
1196 self.m_BasicHeader = self.dataOutObj.m_BasicHeader.copy()
1181 self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy()
1197 self.m_SystemHeader = self.dataOutObj.m_SystemHeader.copy()
1182 self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy()
1198 self.m_RadarControllerHeader = self.dataOutObj.m_RadarControllerHeader.copy()
1183 self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy()
1199 self.m_ProcessingHeader = self.dataOutObj.m_ProcessingHeader.copy()
1184
1200
1185 self.dataType = self.m_DataObj.dataType
1201 self.dataType = self.dataOutObj.dataType
1186
1202
1187
1203
1188 def setup(self, path, set=0, ext=None):
1204 def setup(self, path, set=0, ext=None):
Show file before | Show file after | Hide comments
@@ -53,13 +53,13 class SpectraReader(JRODataReader):
53
53
54 readerObj.getData()
54 readerObj.getData()
55
55
56 print readerObj.m_Spectra.data
56 print readerObj.dataOutObj.data
57
57
58 if readerObj.flagNoMoreFiles:
58 if readerObj.flagNoMoreFiles:
59 break
59 break
60
60
61 """
61 """
62 m_DataObj = None
62 dataOutObj = None
63
63
64 data_spc = None
64 data_spc = None
65 data_cspc = None
65 data_cspc = None
@@ -70,19 +70,16 class SpectraReader(JRODataReader):
70 pts2read_DCchannels = 0
70 pts2read_DCchannels = 0
71
71
72 nChannels = 0
72 nChannels = 0
73
74 nPairs = 0
73 nPairs = 0
75
74
76 #pairList = None
75 flag_cspc = False
77
78 channelList = None
79
76
80 def __init__(self, m_Spectra=None):
77 def __init__(self, dataOutObj=None):
81 """
78 """
82 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
79 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
83
80
84 Inputs:
81 Inputs:
85 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
82 dataOutObj : Objeto de la clase Spectra. Este objeto sera utilizado para
86 almacenar un perfil de datos cada vez que se haga un requerimiento
83 almacenar un perfil de datos cada vez que se haga un requerimiento
87 (getData). El perfil sera obtenido a partir del buffer de datos,
84 (getData). El perfil sera obtenido a partir del buffer de datos,
88 si el buffer esta vacio se hara un nuevo proceso de lectura de un
85 si el buffer esta vacio se hara un nuevo proceso de lectura de un
@@ -90,17 +87,10 class SpectraReader(JRODataReader):
90 Si este parametro no es pasado se creara uno internamente.
87 Si este parametro no es pasado se creara uno internamente.
91
88
92 Affected:
89 Affected:
93 self.m_DataObj
90 self.dataOutObj
94
91
95 Return : None
92 Return : None
96 """
93 """
97 if m_Spectra == None:
98 m_Spectra = Spectra()
99
100 if not( isinstance(m_Spectra, Spectra) ):
101 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
102
103 self.m_DataObj = m_Spectra
104
94
105 self.data_spc = None
95 self.data_spc = None
106 self.data_cspc = None
96 self.data_cspc = None
@@ -174,13 +164,12 class SpectraReader(JRODataReader):
174
164
175 self.blocksize = 0
165 self.blocksize = 0
176
166
177 #pairList = None
167 def createObjByDefault(self):
178
179 channelList = None
180
168
181 self.flag_cspc = False
169 dataObj = Spectra()
182
170
183
171 return dataObj
172
184 def __hasNotDataInBuffer(self):
173 def __hasNotDataInBuffer(self):
185 return 1
174 return 1
186
175
@@ -196,8 +185,8 class SpectraReader(JRODataReader):
196 self.pts2read_CrossSpectra
185 self.pts2read_CrossSpectra
197 self.pts2read_DCchannels
186 self.pts2read_DCchannels
198 self.blocksize
187 self.blocksize
199 self.m_DataObj.nChannels
188 self.dataOutObj.nChannels
200 self.m_DataObj.nPairs
189 self.dataOutObj.nPairs
201
190
202 Return:
191 Return:
203 None
192 None
@@ -212,16 +201,13 class SpectraReader(JRODataReader):
212 else:
201 else:
213 self.nPairs = self.nPairs + 1 #par de canales diferentes
202 self.nPairs = self.nPairs + 1 #par de canales diferentes
214 self.pairList.append( (self.m_ProcessingHeader.spectraComb[i], self.m_ProcessingHeader.spectraComb[i+1]) )
203 self.pairList.append( (self.m_ProcessingHeader.spectraComb[i], self.m_ProcessingHeader.spectraComb[i+1]) )
215
216 if self.nPairs > 0:
217 self.flag_cspc = True
218
204
219 pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock
205 pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock
220
206
221 self.pts2read_SelfSpectra = int(self.nChannels * pts2read)
207 self.pts2read_SelfSpectra = int(self.nChannels * pts2read)
222 self.blocksize = self.pts2read_SelfSpectra
208 self.blocksize = self.pts2read_SelfSpectra
223
209
224 if self.flag_cspc:
210 if self.m_ProcessingHeader.flag_cspc:
225 self.pts2read_CrossSpectra = int(self.nPairs * pts2read)
211 self.pts2read_CrossSpectra = int(self.nPairs * pts2read)
226 self.blocksize += self.pts2read_CrossSpectra
212 self.blocksize += self.pts2read_CrossSpectra
227
213
@@ -230,8 +216,6 class SpectraReader(JRODataReader):
230 self.blocksize += self.pts2read_DCchannels
216 self.blocksize += self.pts2read_DCchannels
231
217
232 # self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
218 # self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
233
234 self.channelList = numpy.arange(self.nChannels)
235
219
236
220
237 def readBlock(self):
221 def readBlock(self):
@@ -312,7 +296,7 class SpectraReader(JRODataReader):
312 1 : Si hizo una buena copia del buffer
296 1 : Si hizo una buena copia del buffer
313
297
314 Affected:
298 Affected:
315 self.m_DataObj
299 self.dataOutObj
316 self.datablockIndex
300 self.datablockIndex
317 self.flagResetProcessing
301 self.flagResetProcessing
318 self.flagIsNewBlock
302 self.flagIsNewBlock
@@ -337,15 +321,15 class SpectraReader(JRODataReader):
337 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
321 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
338
322
339 if self.data_dc == None:
323 if self.data_dc == None:
340 self.m_DataObj.flagNoData = True
324 self.dataOutObj.flagNoData = True
341 return 0
325 return 0
342
326
343 self.m_DataObj.flagNoData = False
327 self.dataOutObj.flagNoData = False
344 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
328 self.dataOutObj.flagResetProcessing = self.flagResetProcessing
345
329
346 self.m_DataObj.data_spc = self.data_spc
330 self.dataOutObj.data_spc = self.data_spc
347 self.m_DataObj.data_cspc = self.data_cspc
331 self.dataOutObj.data_cspc = self.data_cspc
348 self.m_DataObj.data_dc = self.data_dc
332 self.dataOutObj.data_dc = self.data_dc
349
333
350 return 1
334 return 1
351
335
@@ -357,7 +341,7 class SpectraWriter(JRODataWriter):
357 de los datos siempre se realiza por bloques.
341 de los datos siempre se realiza por bloques.
358 """
342 """
359
343
360 m_DataObj = None
344 dataOutObj = None
361
345
362 shape_spc_Buffer = None
346 shape_spc_Buffer = None
363 shape_cspc_Buffer = None
347 shape_cspc_Buffer = None
@@ -368,12 +352,12 class SpectraWriter(JRODataWriter):
368 data_dc = None
352 data_dc = None
369
353
370
354
371 def __init__(self, m_Spectra=None):
355 def __init__(self, dataOutObj=None):
372 """
356 """
373 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
357 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
374
358
375 Affected:
359 Affected:
376 self.m_DataObj
360 self.dataOutObj
377 self.m_BasicHeader
361 self.m_BasicHeader
378 self.m_SystemHeader
362 self.m_SystemHeader
379 self.m_RadarControllerHeader
363 self.m_RadarControllerHeader
@@ -381,13 +365,13 class SpectraWriter(JRODataWriter):
381
365
382 Return: None
366 Return: None
383 """
367 """
384 if m_Spectra == None:
368 if dataOutObj == None:
385 m_Spectra = Spectra()
369 dataOutObj = Spectra()
386
370
387 if not( isinstance(m_Spectra, Spectra) ):
371 if not( isinstance(dataOutObj, Spectra) ):
388 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
372 raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
389
373
390 self.m_DataObj = m_Spectra
374 self.dataOutObj = dataOutObj
391
375
392 self.ext = ".pdata"
376 self.ext = ".pdata"
393
377
@@ -449,11 +433,11 class SpectraWriter(JRODataWriter):
449
433
450 Return: None
434 Return: None
451 """
435 """
452 self.shape_spc_Buffer = (self.m_DataObj.nChannels,
436 self.shape_spc_Buffer = (self.dataOutObj.nChannels,
453 self.m_ProcessingHeader.numHeights,
437 self.m_ProcessingHeader.numHeights,
454 self.m_ProcessingHeader.profilesPerBlock)
438 self.m_ProcessingHeader.profilesPerBlock)
455
439
456 self.shape_cspc_Buffer = (self.m_DataObj.nPairs,
440 self.shape_cspc_Buffer = (self.dataOutObj.nPairs,
457 self.m_ProcessingHeader.numHeights,
441 self.m_ProcessingHeader.numHeights,
458 self.m_ProcessingHeader.profilesPerBlock)
442 self.m_ProcessingHeader.profilesPerBlock)
459
443
@@ -526,18 +510,18 class SpectraWriter(JRODataWriter):
526 """
510 """
527 self.flagIsNewBlock = 0
511 self.flagIsNewBlock = 0
528
512
529 if self.m_DataObj.flagNoData:
513 if self.dataOutObj.flagNoData:
530 return 0
514 return 0
531
515
532 if self.m_DataObj.flagResetProcessing:
516 if self.dataOutObj.flagResetProcessing:
533 self.data_spc.fill(0)
517 self.data_spc.fill(0)
534 self.data_cspc.fill(0)
518 self.data_cspc.fill(0)
535 self.data_dc.fill(0)
519 self.data_dc.fill(0)
536 self.setNextFile()
520 self.setNextFile()
537
521
538 self.data_spc = self.m_DataObj.data_spc
522 self.data_spc = self.dataOutObj.data_spc
539 self.data_cspc = self.m_DataObj.data_cspc
523 self.data_cspc = self.dataOutObj.data_cspc
540 self.data_dc = self.m_DataObj.data_dc
524 self.data_dc = self.dataOutObj.data_dc
541
525
542 # #self.m_ProcessingHeader.dataBlocksPerFile)
526 # #self.m_ProcessingHeader.dataBlocksPerFile)
543 if self.hasAllDataInBuffer():
527 if self.hasAllDataInBuffer():
Show file before | Show file after | Hide comments
@@ -61,7 +61,7 class VoltageReader(JRODataReader):
61 break
61 break
62
62
63 """
63 """
64 m_DataObj = None
64 dataOutObj = None
65
65
66 datablock = None
66 datablock = None
67
67
@@ -70,12 +70,12 class VoltageReader(JRODataReader):
70 optchar = "D"
70 optchar = "D"
71
71
72
72
73 def __init__(self, m_Voltage=None):
73 def __init__(self, dataOutObj=None):
74 """
74 """
75 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
75 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
76
76
77 Input:
77 Input:
78 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
78 dataOutObj : Objeto de la clase Voltage. Este objeto sera utilizado para
79 almacenar un perfil de datos cada vez que se haga un requerimiento
79 almacenar un perfil de datos cada vez que se haga un requerimiento
80 (getData). El perfil sera obtenido a partir del buffer de datos,
80 (getData). El perfil sera obtenido a partir del buffer de datos,
81 si el buffer esta vacio se hara un nuevo proceso de lectura de un
81 si el buffer esta vacio se hara un nuevo proceso de lectura de un
@@ -83,18 +83,11 class VoltageReader(JRODataReader):
83 Si este parametro no es pasado se creara uno internamente.
83 Si este parametro no es pasado se creara uno internamente.
84
84
85 Variables afectadas:
85 Variables afectadas:
86 self.m_DataObj
86 self.dataOutObj
87
87
88 Return:
88 Return:
89 None
89 None
90 """
90 """
91 if m_Voltage == None:
92 m_Voltage = Voltage()
93
94 if not(isinstance(m_Voltage, Voltage)):
95 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
96
97 self.m_DataObj = m_Voltage
98
91
99 self.datablock = None
92 self.datablock = None
100
93
@@ -172,6 +165,12 class VoltageReader(JRODataReader):
172
165
173 self.blocksize = 0
166 self.blocksize = 0
174
167
168 def createObjByDefault(self):
169
170 dataObj = Voltage()
171
172 return dataObj
173
175 def __hasNotDataInBuffer(self):
174 def __hasNotDataInBuffer(self):
176 if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock:
175 if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock:
177 return 1
176 return 1
@@ -251,11 +250,11 class VoltageReader(JRODataReader):
251 buffer. Si no hay mas archivos a leer retorna None.
250 buffer. Si no hay mas archivos a leer retorna None.
252
251
253 Variables afectadas:
252 Variables afectadas:
254 self.m_DataObj
253 self.dataOutObj
255 self.profileIndex
254 self.profileIndex
256
255
257 Affected:
256 Affected:
258 self.m_DataObj
257 self.dataOutObj
259 self.profileIndex
258 self.profileIndex
260 self.flagResetProcessing
259 self.flagResetProcessing
261 self.flagIsNewBlock
260 self.flagIsNewBlock
@@ -279,22 +278,22 class VoltageReader(JRODataReader):
279 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
278 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
280
279
281 if self.datablock == None:
280 if self.datablock == None:
282 self.m_DataObj.flagNoData = True
281 self.dataOutObj.flagNoData = True
283 return 0
282 return 0
284
283
285 time = self.m_BasicHeader.utc + self.profileIndex * self.ippSeconds
284 time = self.m_BasicHeader.utc + self.profileIndex * self.ippSeconds
286 self.m_DataObj.m_BasicHeader.utc = time
285 self.dataOutObj.m_BasicHeader.utc = time
287
286
288 self.m_DataObj.flagNoData = False
287 self.dataOutObj.flagNoData = False
289 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
288 self.dataOutObj.flagResetProcessing = self.flagResetProcessing
290
289
291 self.m_DataObj.data = self.datablock[:,self.profileIndex,:]
290 self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
292
291
293 self.profileIndex += 1
292 self.profileIndex += 1
294
293
295 #call setData - to Data Object
294 #call setData - to Data Object
296
295
297 return 1 #self.m_DataObj.data
296 return 1 #self.dataOutObj.data
298
297
299
298
300 class VoltageWriter(JRODataWriter):
299 class VoltageWriter(JRODataWriter):
@@ -304,7 +303,7 class VoltageWriter(JRODataWriter):
304 """
303 """
305 __configHeaderFile = 'wrSetHeadet.txt'
304 __configHeaderFile = 'wrSetHeadet.txt'
306
305
307 m_DataObj = None
306 dataOutObj = None
308
307
309 ext = ".r"
308 ext = ".r"
310
309
@@ -317,22 +316,22 class VoltageWriter(JRODataWriter):
317 shapeBuffer = None
316 shapeBuffer = None
318
317
319
318
320 def __init__(self, m_Voltage=None):
319 def __init__(self, dataOutObj=None):
321 """
320 """
322 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
321 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
323
322
324 Affected:
323 Affected:
325 self.m_DataObj
324 self.dataOutObj
326
325
327 Return: None
326 Return: None
328 """
327 """
329 if m_Voltage == None:
328 if dataOutObj == None:
330 m_Voltage = Voltage()
329 dataOutObj = Voltage()
331
330
332 if not( isinstance(m_Voltage, Voltage) ):
331 if not( isinstance(dataOutObj, Voltage) ):
333 raise ValueError, "in VoltageReader, m_Voltage must be an Spectra class object"
332 raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
334
333
335 self.m_DataObj = m_Voltage
334 self.dataOutObj = dataOutObj
336
335
337
336
338 def hasAllDataInBuffer(self):
337 def hasAllDataInBuffer(self):
@@ -408,16 +407,16 class VoltageWriter(JRODataWriter):
408 """
407 """
409 self.flagIsNewBlock = 0
408 self.flagIsNewBlock = 0
410
409
411 if self.m_DataObj.flagNoData:
410 if self.dataOutObj.flagNoData:
412 return 0
411 return 0
413
412
414 if self.m_DataObj.flagResetProcessing:
413 if self.dataOutObj.flagResetProcessing:
415
414
416 self.datablock.fill(0)
415 self.datablock.fill(0)
417 self.profileIndex = 0
416 self.profileIndex = 0
418 self.setNextFile()
417 self.setNextFile()
419
418
420 self.datablock[:,self.profileIndex,:] = self.m_DataObj.data
419 self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
421
420
422 self.profileIndex += 1
421 self.profileIndex += 1
423
422
Show file before | Show file after | Hide comments
@@ -32,16 +32,7 class Data:
32
32
33 return copy.deepcopy(self)
33 return copy.deepcopy(self)
34
34
35 class Noise(Data):
36 '''
37 classdocs
38 '''
39
35
40 def __init__(self):
41 '''
42 Constructor
43 '''
44 pass
45
36
46 class JROData(Data):
37 class JROData(Data):
47 '''
38 '''
@@ -56,7 +47,7 class JROData(Data):
56
47
57 m_BasicHeader = BasicHeader()
48 m_BasicHeader = BasicHeader()
58
49
59 m_NoiseObj = Noise()
50 noise = None
60
51
61 type = None
52 type = None
62
53
@@ -72,6 +63,10 class JROData(Data):
72
63
73 channelList = None
64 channelList = None
74
65
66 channelIndexList = None
67
68 pairList = None
69
75 flagNoData = False
70 flagNoData = False
76
71
77 flagResetProcessing = False
72 flagResetProcessing = False
@@ -101,6 +96,7 class JROData(Data):
101 xf = xi + self.m_ProcessingHeader.numHeights*step
96 xf = xi + self.m_ProcessingHeader.numHeights*step
102
97
103 self.heightList = numpy.arange(xi, xf, step)
98 self.heightList = numpy.arange(xi, xf, step)
99 self.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
104 self.channelList = numpy.arange(self.m_SystemHeader.numChannels)
100 self.channelList = numpy.arange(self.m_SystemHeader.numChannels)
105
101
106 self.nHeights = len(self.heightList)
102 self.nHeights = len(self.heightList)
Show file before | Show file after | Hide comments
@@ -307,6 +307,8 class ProcessingHeader(Header):
307 incoherentInt = None
307 incoherentInt = None
308 totalSpectra = None
308 totalSpectra = None
309 struct = None
309 struct = None
310 flag_dc = None
311 flag_cspc = None
310
312
311 def __init__(self):
313 def __init__(self):
312 self.size = 0
314 self.size = 0
@@ -343,6 +345,7 class ProcessingHeader(Header):
343 self.numBaud = 0
345 self.numBaud = 0
344 self.shif_fft = False
346 self.shif_fft = False
345 self.flag_dc = False
347 self.flag_dc = False
348 self.flag_cspc = False
346
349
347 def read(self, fp):
350 def read(self, fp):
348 try:
351 try:
@@ -376,6 +379,22 class ProcessingHeader(Header):
376
379
377 if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
380 if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
378 self.flag_dc = True
381 self.flag_dc = True
382
383 nChannels = 0
384 nPairs = 0
385 pairList = []
386
387 for i in range( 0, self.totalSpectra*2, 2 ):
388 if self.spectraComb[i] == self.spectraComb[i+1]:
389 nChannels = nChannels + 1 #par de canales iguales
390 else:
391 nPairs = nPairs + 1 #par de canales diferentes
392 pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
393
394 self.flag_cspc = False
395 if nPairs > 0:
396 self.flag_cspc = True
397
379 except:
398 except:
380 return 0
399 return 0
381
400
Show file before | Show file after | Hide comments
@@ -5,7 +5,7 Created on Feb 7, 2012
5 @version $Id$
5 @version $Id$
6 '''
6 '''
7
7
8 from JROData import JROData, Noise
8 from JROData import JROData
9 from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
9 from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
10
10
11 class Spectra(JROData):
11 class Spectra(JROData):
@@ -39,8 +39,6 class Spectra(JROData):
39
39
40 self.m_BasicHeader = BasicHeader()
40 self.m_BasicHeader = BasicHeader()
41
41
42 self.m_NoiseObj = Noise()
43
44 self.type = "Spectra"
42 self.type = "Spectra"
45
43
46 self.dataType = None
44 self.dataType = None
Show file before | Show file after | Hide comments
@@ -5,7 +5,7 Created on Feb 7, 2012
5 @version $Id$
5 @version $Id$
6 '''
6 '''
7
7
8 from JROData import JROData, Noise
8 from JROData import JROData
9 from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
9 from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
10
10
11 class Voltage(JROData):
11 class Voltage(JROData):
@@ -32,8 +32,6 class Voltage(JROData):
32
32
33 self.m_BasicHeader = BasicHeader()
33 self.m_BasicHeader = BasicHeader()
34
34
35 self.m_NoiseObj = Noise()
36
37 self.type = "Voltage"
35 self.type = "Voltage"
38
36
39 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
37 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
Show file before | Show file after | Hide comments
@@ -1,7 +1,7
1 import numpy
1 import numpy
2 from Model.Spectra import Spectra
2 from Model.Spectra import Spectra
3
3
4 def hildebrand_sekhon(Data, navg=1):
4 def hildebrand_sekhon(Data, navg):
5 """
5 """
6 This method is for the objective determination of de noise level in Doppler spectra. This
6 This method is for the objective determination of de noise level in Doppler spectra. This
7 implementation technique is based on the fact that the standard deviation of the spectral
7 implementation technique is based on the fact that the standard deviation of the spectral
@@ -15,6 +15,7 def hildebrand_sekhon(Data, navg=1):
15 -1 : any error
15 -1 : any error
16 anoise : noise's level
16 anoise : noise's level
17 """
17 """
18
18 divisor = 8
19 divisor = 8
19 ratio = 7 / divisor
20 ratio = 7 / divisor
20 data = Data.reshape(-1)
21 data = Data.reshape(-1)
@@ -63,50 +64,150 def hildebrand_sekhon(Data, navg=1):
63
64
64 return anoise;
65 return anoise;
65
66
67 def sorting_bruce(Data, navg):
68 sortdata = numpy.sort(Data)
69 lenOfData = len(Data)
70 nums_min = lenOfData/10
71
72 if (lenOfData/10) > 0:
73 nums_min = lenOfData/10
74 else:
75 nums_min = 0
76
77 rtest = 1.0 + 1.0/navg
78
79 sum = 0.
80
81 sumq = 0.
82
83 j = 0
84
85 cont = 1
86
87 while((cont==1)and(j<lenOfData)):
88
89 sum += sortdata[j]
90
91 sumq += sortdata[j]**2
92
93 j += 1
94
95 if j > nums_min:
96 if ((sumq*j) <= (rtest*sum**2)):
97 lnoise = sum / j
98 else:
99 j = j - 1
100 sum = sum - sordata[j]
101 sumq = sumq - sordata[j]**2
102 cont = 0
103
104 if j == nums_min:
105 lnoise = sum /j
106
107 return lnoise
66
108
67 class Noise:
109 class Noise:
68 """
110 """
69 Clase que implementa los metodos necesarios para deternimar el nivel de ruido en un Spectro Doppler
111 Clase que implementa los metodos necesarios para deternimar el nivel de ruido en un Spectro Doppler
70 """
112 """
71 m_DataObj = None
113 data = None
114 noise = None
115 dim = None
72
116
117 def __init__(self, data=None):
118 """
119 Inicializador de la clase Noise para la la determinacion del nivel de ruido en un Spectro Doppler.
73
120
74 def __init__(self, m_Spectra=None):
121 Inputs:
122 data: Numpy array de la forma nChan x nHeis x nProfiles
123
124 Affected:
125 self.noise
126
127 Return:
128 None
129 """
130
131 self.data = data
132 self.dim = None
133 self.nChannels = None
134 self.noise = None
135
136 def setNoise(self, data):
75 """
137 """
76 Inicializador de la clase Noise para la la determinacion del nivel de ruido en un Spectro Doppler.
138 Inicializador de la clase Noise para la la determinacion del nivel de ruido en un Spectro Doppler.
77
139
140 Inputs:
141 data: Numpy array de la forma nChan x nHeis x nProfiles
142
78 Affected:
143 Affected:
79 self.m_DataObj
144 self.noise
80
145
81 Return:
146 Return:
82 None
147 None
83 """
148 """
84 if m_Spectra == None:
85 m_Spectra = Spectra()
86
149
87 if not(isinstance(m_Spectra, Spectra)):
150 if data == None:
88 raise ValueError, "in Noise class, m_Spectra must be an Spectra class object"
151 return 0
152
153 shape = data.shape
154 self.dim = len(shape)
155 if self.dim == 3:
156 nChan, nProfiles, nHeis = shape
157 elif self.dim == 2:
158 nChan, nHeis = shape
159 else:
160 raise ValueError, ""
89
161
90 self.m_DataObj = m_Spectra
162 self.nChannels = nChan
163 self.data = data.copy()
164 self.noise = numpy.zeros(nChan)
91
165
166 return 1
167
92
168
93 def getNoiseLevelByHildebrandSekhon(self):
169 def byHildebrand(self, navg=1):
94 """
170 """
95 Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
171 Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
96
172
97 Return:
173 Return:
98 noise level
174 noiselevel
99 """
175 """
100 data = self.m_DataObj.data_spc
176
101 daux = None
177 daux = None
102
178
103 for channel in range(self.m_DataObj.nChannels):
179 for channel in range(self.nChannels):
180 daux = self.data[channel,:,:]
181 self.noise[channel] = hildebrand_sekhon(daux, navg)
182 return self.noise
183
184 def byWindow(self, heiIndexMin, heiIndexMax, freqIndexMin, freqIndexMax):
185 """
186 Determina el ruido del canal utilizando la ventana indicada con las coordenadas:
187 (heiIndexMIn, freqIndexMin) hasta (heiIndexMax, freqIndexMAx)
188
189 Inputs:
190 heiIndexMin: Limite inferior del eje de alturas
191 heiIndexMax: Limite superior del eje de alturas
192 freqIndexMin: Limite inferior del eje de frecuencia
193 freqIndexMax: Limite supoerior del eje de frecuencia
194 """
195
196 data = self.data[:, heiIndexMin:heiIndexMax, freqIndexMin:freqIndexMax]
197
198 for channel in range(self.nChannels):
104 daux = data[channel,:,:]
199 daux = data[channel,:,:]
105 noiselevel = hildebrand_sekhon(daux)
200 self.noise[channel] = numpy.average(daux)
106 print noiselevel
107
201
202 return self.noise
203
204 def bySort(self,navg = 1):
205 daux = None
206
207 for channel in range(self.nChannels):
208 daux = self.data[channel,:,:]
209 self.noise[channel] = sorting_bruce(daux, navg)
210
211 return self.noise
108
212
109 for pair in range(self.m_DataObj.nPairs):
213 No newline at end of file
110 daux = data[pair,:,:]
111 noiselevel = hildebrand_sekhon(daux)
112 print noiselevel
Show file before | Show file after | Hide comments
@@ -13,7 +13,7 sys.path.append(path)
13 from Model.Spectra import Spectra
13 from Model.Spectra import Spectra
14 from IO.SpectraIO import SpectraWriter
14 from IO.SpectraIO import SpectraWriter
15 from Graphics.SpectraPlot import Spectrum
15 from Graphics.SpectraPlot import Spectrum
16
16 from JRONoise import Noise
17
17
18 class SpectraProcessor:
18 class SpectraProcessor:
19 '''
19 '''
@@ -24,13 +24,7 class SpectraProcessor:
24
24
25 dataOutObj = None
25 dataOutObj = None
26
26
27 integratorObjIndex = None
27 noiseObj = None
28
29 decoderObjIndex = None
30
31 writerObjIndex = None
32
33 plotterObjIndex = None
34
28
35 integratorObjList = []
29 integratorObjList = []
36
30
@@ -40,26 +34,34 class SpectraProcessor:
40
34
41 plotterObjList = []
35 plotterObjList = []
42
36
37 integratorObjIndex = None
38
39 decoderObjIndex = None
40
41 writerObjIndex = None
42
43 plotterObjIndex = None
44
43 buffer = None
45 buffer = None
44
46
45 ptsId = 0
47 profIndex = 0
46
48
47 nFFTPoints = None
49 nFFTPoints = None
48
50
51 nChannels = None
52
53 nHeights = None
54
55 nPairs = None
56
49 pairList = None
57 pairList = None
50
58
51
59
52 def __init__(self, dataInObj=None, dataOutObj=None):
60 def __init__(self):
53 '''
61 '''
54 Constructor
62 Constructor
55 '''
63 '''
56 self.dataInObj = dataInObj
57
64
58 if dataOutObj == None:
59 self.dataOutObj = Spectra()
60 else:
61 self.dataOutObj = dataOutObj
62
63 self.integratorObjIndex = None
65 self.integratorObjIndex = None
64 self.decoderObjIndex = None
66 self.decoderObjIndex = None
65 self.writerObjIndex = None
67 self.writerObjIndex = None
@@ -70,30 +72,79 class SpectraProcessor:
70 self.writerObjList = []
72 self.writerObjList = []
71 self.plotterObjList = []
73 self.plotterObjList = []
72
74
75 self.noiseObj = Noise()
73 self.buffer = None
76 self.buffer = None
74 self.ptsId = 0
77 self.profIndex = 0
75
76 def setIO(self,inputObject, outputObject):
77
78 # if not( isinstance(inputObject, Voltage) ):
79 # print 'InputObject must be an instance from Voltage()'
80 # sys.exit(0)
81
78
82 if not( isinstance(outputObject, Spectra) ):
79 def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairList=None):
83 print 'OutputObject must be an instance from Spectra()'
84 sys.exit(0)
85
80
86 self.dataInObj = inputObject
81 if dataInObj == None:
87 self.dataOutObj = outputObject
82 raise ValueError, ""
88
83
89 def setup(self,nFFTPoints=None, pairList=None):
90 if nFFTPoints == None:
84 if nFFTPoints == None:
91 nFFTPoints = self.dataOutObj.nFFTPoints
85 raise ValueError, ""
86
87 self.dataInObj = dataInObj
92
88
89 if dataOutObj == None:
90 dataOutObj = Spectra()
91
92 self.dataOutObj = dataOutObj
93 self.noiseObj = Noise()
94
95 ##########################################
93 self.nFFTPoints = nFFTPoints
96 self.nFFTPoints = nFFTPoints
97 self.nChannels = self.dataInObj.nChannels
98 self.nHeights = self.dataInObj.nHeights
94 self.pairList = pairList
99 self.pairList = pairList
100 if pairList != None:
101 self.nPairs = len(pairList)
102 else:
103 self.nPairs = 0
104
105 self.dataOutObj.heightList = self.dataInObj.heightList
106 self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
107 self.dataOutObj.m_BasicHeader = self.dataInObj.m_BasicHeader.copy()
108 self.dataOutObj.m_ProcessingHeader = self.dataInObj.m_ProcessingHeader.copy()
109 self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
110 self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
111
112 self.dataOutObj.dataType = self.dataInObj.dataType
113 self.dataOutObj.nPairs = self.nPairs
114 self.dataOutObj.nChannels = self.nChannels
115 self.dataOutObj.nProfiles = self.nFFTPoints
116 self.dataOutObj.nHeights = self.nHeights
117 self.dataOutObj.nFFTPoints = self.nFFTPoints
118 #self.dataOutObj.data = None
119
120 self.dataOutObj.m_SystemHeader.numChannels = self.nChannels
121 self.dataOutObj.m_SystemHeader.nProfiles = self.nFFTPoints
122
123 self.dataOutObj.m_ProcessingHeader.totalSpectra = self.nChannels + self.nPairs
124 self.dataOutObj.m_ProcessingHeader.profilesPerBlock = self.nFFTPoints
125 self.dataOutObj.m_ProcessingHeader.numHeights = self.nHeights
126 self.dataOutObj.m_ProcessingHeader.shif_fft = True
127
128 spectraComb = numpy.zeros( (self.nChannels+self.nPairs)*2,numpy.dtype('u1'))
129 k = 0
130 for i in range( 0,self.nChannels*2,2 ):
131 spectraComb[i] = k
132 spectraComb[i+1] = k
133 k += 1
134
135 k *= 2
136
137 if self.pairList != None:
138
139 for pair in self.pairList:
140 spectraComb[k] = pair[0]
141 spectraComb[k+1] = pair[1]
142 k += 2
143
144 self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
145
146 return self.dataOutObj
95
147
96 # def init(self, nFFTPoints, pairList=None):
97 def init(self):
148 def init(self):
98
149
99 self.integratorObjIndex = 0
150 self.integratorObjIndex = 0
@@ -101,18 +152,37 class SpectraProcessor:
101 self.writerObjIndex = 0
152 self.writerObjIndex = 0
102 self.plotterObjIndex = 0
153 self.plotterObjIndex = 0
103
154
104 # if nFFTPoints == None:
155 if self.dataInObj.type == "Voltage":
105 # nFFTPoints = self.dataOutObj.nFFTPoints
156
106 #
157 if self.buffer == None:
107 # self.nFFTPoints = nFFTPoints
158 self.buffer = numpy.zeros((self.nChannels,
108 # self.pairList = pairList
159 self.nFFTPoints,
109 #
160 self.nHeights),
110 if not( isinstance(self.dataInObj, Spectra) ):
161 dtype='complex')
111 self.__getFft()
162
112 else:
163 self.buffer[:,self.profIndex,:] = self.dataInObj.data
164 self.profIndex += 1
165
166 if self.profIndex == self.nFFTPoints:
167 self.__getFft()
168 self.dataOutObj.flagNoData = False
169
170 self.buffer = None
171 self.profIndex = 0
172 return
173
174 self.dataOutObj.flagNoData = True
175
176 return
177
178 #Other kind of data
179 if self.dataInObj.type == "Spectra":
113 self.dataOutObj.copy(self.dataInObj)
180 self.dataOutObj.copy(self.dataInObj)
114
181 self.dataOutObj.flagNoData = False
115
182 return
183
184 raise ValueError, "The datatype is not valid"
185
116 def __getFft(self):
186 def __getFft(self):
117 """
187 """
118 Convierte valores de Voltaje a Spectra
188 Convierte valores de Voltaje a Spectra
@@ -126,7 +196,7 class SpectraProcessor:
126 self.dataOutObj.m_ProcessingHeader
196 self.dataOutObj.m_ProcessingHeader
127 self.dataOutObj.m_RadarControllerHeader
197 self.dataOutObj.m_RadarControllerHeader
128 self.dataOutObj.m_SystemHeader
198 self.dataOutObj.m_SystemHeader
129 self.ptsId
199 self.profIndex
130 self.buffer
200 self.buffer
131 self.dataOutObj.flagNoData
201 self.dataOutObj.flagNoData
132 self.dataOutObj.dataType
202 self.dataOutObj.dataType
@@ -142,20 +212,6 class SpectraProcessor:
142 """
212 """
143 if self.dataInObj.flagNoData:
213 if self.dataInObj.flagNoData:
144 return 0
214 return 0
145
146 blocksize = 0
147 nFFTPoints = self.nFFTPoints
148 nChannels, nheis = self.dataInObj.data.shape
149
150 if self.buffer == None:
151 self.buffer = numpy.zeros((nChannels, nFFTPoints, nheis), dtype='complex')
152
153 self.buffer[:,self.ptsId,:] = self.dataInObj.data
154 self.ptsId += 1
155
156 if self.ptsId < self.nFFTPoints:
157 self.dataOutObj.flagNoData = True
158 return
159
215
160 fft_volt = numpy.fft.fft(self.buffer,axis=1)
216 fft_volt = numpy.fft.fft(self.buffer,axis=1)
161 dc = fft_volt[:,0,:]
217 dc = fft_volt[:,0,:]
@@ -164,69 +220,24 class SpectraProcessor:
164 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
220 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
165 spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))
221 spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))
166
222
223 blocksize = 0
167 blocksize += dc.size
224 blocksize += dc.size
168 blocksize += spc.size
225 blocksize += spc.size
169
226
170 cspc = None
227 cspc = None
171 nPair = 0
228 pairIndex = 0
172 if self.pairList != None:
229 if self.pairList != None:
173 #calculo de cross-spectra
230 #calculo de cross-spectra
174 nPairs = len(self.pairList)
231 cspc = numpy.zeros((self.nPairs, self.nFFTPoints, self.nHeights), dtype='complex')
175 cspc = numpy.zeros((nPairs, nFFTPoints, nheis), dtype='complex')
176 for pair in self.pairList:
232 for pair in self.pairList:
177 cspc[nPair,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
233 cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
178 nPair += 1
234 pairIndex += 1
179 blocksize += cspc.size
235 blocksize += cspc.size
180
236
181 self.dataOutObj.data_spc = spc
237 self.dataOutObj.data_spc = spc
182 self.dataOutObj.data_cspc = cspc
238 self.dataOutObj.data_cspc = cspc
183 self.dataOutObj.data_dc = dc
239 self.dataOutObj.data_dc = dc
184
185 self.ptsId = 0
186 self.buffer = None
187 self.dataOutObj.flagNoData = False
188
189 self.dataOutObj.heightList = self.dataInObj.heightList
190 self.dataOutObj.channelList = self.dataInObj.channelList
191 self.dataOutObj.m_BasicHeader = self.dataInObj.m_BasicHeader.copy()
192 self.dataOutObj.m_ProcessingHeader = self.dataInObj.m_ProcessingHeader.copy()
193 self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
194 self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
195
196 self.dataOutObj.dataType = self.dataInObj.dataType
197 self.dataOutObj.nPairs = nPair
198 self.dataOutObj.nChannels = nChannels
199 self.dataOutObj.nProfiles = nFFTPoints
200 self.dataOutObj.nHeights = nheis
201 self.dataOutObj.nFFTPoints = nFFTPoints
202 #self.dataOutObj.data = None
203
204 self.dataOutObj.m_SystemHeader.numChannels = nChannels
205 self.dataOutObj.m_SystemHeader.nProfiles = nFFTPoints
206
207 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
240 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
208 self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPair
209 self.dataOutObj.m_ProcessingHeader.profilesPerBlock = nFFTPoints
210 self.dataOutObj.m_ProcessingHeader.numHeights = nheis
211 self.dataOutObj.m_ProcessingHeader.shif_fft = True
212
213 spectraComb = numpy.zeros( (nChannels+nPair)*2,numpy.dtype('u1'))
214 k = 0
215 for i in range( 0,nChannels*2,2 ):
216 spectraComb[i] = k
217 spectraComb[i+1] = k
218 k += 1
219
220 k *= 2
221
222 if self.pairList != None:
223
224 for pair in self.pairList:
225 spectraComb[k] = pair[0]
226 spectraComb[k+1] = pair[1]
227 k += 2
228
229 self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
230
241
231
242
232 def addWriter(self,wrpath):
243 def addWriter(self,wrpath):
@@ -289,36 +300,93 class SpectraProcessor:
289 #print "myIncohIntObj.navg: ",myIncohIntObj.navg
300 #print "myIncohIntObj.navg: ",myIncohIntObj.navg
290 self.dataOutObj.flagNoData = False
301 self.dataOutObj.flagNoData = False
291
302
303 self.getNoise(type="hildebrand",parm=myIncohIntObj.navg)
304 # self.getNoise(type="sort", parm=16)
305
292 else:
306 else:
293 self.dataOutObj.flagNoData = True
307 self.dataOutObj.flagNoData = True
294
308
295 self.integratorObjIndex += 1
309 self.integratorObjIndex += 1
296
310
311 """Calcular el ruido"""
312 # self.getNoise(type="hildebrand", parm=1)
313
297 def removeDC(self, type):
314 def removeDC(self, type):
298
315
299 if self.dataOutObj.flagNoData:
316 if self.dataOutObj.flagNoData:
300 return 0
317 return 0
301 pass
302
318
303 def removeInterference(self):
319 def removeInterference(self):
304
320
305 if self.dataOutObj.flagNoData:
321 if self.dataOutObj.flagNoData:
306 return 0
322 return 0
307 pass
308
323
309 def removeSatellites(self):
324 def removeSatellites(self):
310
325
311 if self.dataOutObj.flagNoData:
326 if self.dataOutObj.flagNoData:
312 return 0
327 return 0
313 pass
314
328
315 def selectChannels(self, channelList, pairList=None):
329 def getNoise(self, type="hildebrand", parm=None):
330
331 self.noiseObj.setNoise(self.dataOutObj.data_spc)
332
333 if type == "hildebrand":
334 noise = self.noiseObj.byHildebrand(parm)
335
336 if type == "window":
337 noise = self.noiseObj.byWindow(parm)
338
339 if type == "sort":
340 noise = self.noiseObj.bySort(parm)
341
342 self.dataOutObj.noise = noise
343 print 10*numpy.log10(noise)
344
345 def selectChannels(self, channelList, pairList=[]):
346
347 channelIndexList = []
348
349 for channel in channelList:
350 if channel in self.dataOutObj.channelList:
351 index = self.dataOutObj.channelList.index(channel)
352 channelIndexList.append(index)
353
354 pairIndexList = []
355
356 for pair in pairList:
357 if pair in self.dataOutObj.pairList:
358 index = self.dataOutObj.pairList.index(pair)
359 pairIndexList.append(index)
360
361 self.selectChannelsByIndex(channelIndexList, pairIndexList)
362
363 def selectChannelsByIndex(self, channelIndexList, pairIndexList=[]):
316 """
364 """
317 Selecciona un bloque de datos en base a canales y pares segun el channelList y el pairList
365 Selecciona un bloque de datos en base a canales y pares segun el
366 channelIndexList y el pairIndexList
318
367
319 Input:
368 Input:
320 channelList : lista sencilla de canales a seleccionar por ej. (2,3,7)
369 channelIndexList : lista de indices de los canales a seleccionar por ej.
321 pairList : tupla de pares que se desea selecionar por ej. ( (0,1), (0,2) )
370
371 Si tenemos los canales
372
373 self.channelList = (2,3,5,7)
374
375 y deseamos escoger los canales (3,7)
376 entonces colocaremos el parametro
377
378 channelndexList = (1,3)
379
380 pairIndexList : tupla de indice depares que se desea selecionar por ej.
381
382 Si tenemos los pares :
383
384 ( (0,1), (0,2), (1,3), (2,5) )
385
386 y deseamos seleccionar los pares ((0,2), (2,5))
387 entonces colocaremos el parametro
388
389 pairIndexList = (1,3)
322
390
323 Affected:
391 Affected:
324 self.dataOutObj.data_spc
392 self.dataOutObj.data_spc
@@ -329,6 +397,7 class SpectraProcessor:
329 self.dataOutObj.m_ProcessingHeader.spectraComb
397 self.dataOutObj.m_ProcessingHeader.spectraComb
330 self.dataOutObj.m_SystemHeader.numChannels
398 self.dataOutObj.m_SystemHeader.numChannels
331
399
400 self.dataOutObj.noise
332 Return:
401 Return:
333 None
402 None
334 """
403 """
@@ -336,71 +405,35 class SpectraProcessor:
336 if self.dataOutObj.flagNoData:
405 if self.dataOutObj.flagNoData:
337 return 0
406 return 0
338
407
339 channelIndexList = []
408 if pairIndexList == []:
340 for channel in channelList:
409 pairIndexList = numpy.arange(len(self.dataOutObj.pairList))
341 if channel in self.dataOutObj.channelList:
410
342 index = self.dataOutObj.channelList.index(channel)
343 channelIndexList.append(index)
344 continue
345
346 raise ValueError, "The value %d in channelList is not valid" %channel
347
348 nProfiles = self.dataOutObj.nProfiles
349 #dataType = self.dataOutObj.dataType
350 nHeights = self.dataOutObj.nHeights #m_ProcessingHeader.numHeights
351 blocksize = 0
352
353 #self spectra
354 nChannels = len(channelIndexList)
411 nChannels = len(channelIndexList)
355 spc = numpy.zeros( (nChannels,nProfiles,nHeights), dtype='float' ) #dataType[0] )
412 nPairs = len(pairIndexList)
356
357 for index, channel in enumerate(channelIndexList):
358 spc[index,:,:] = self.dataOutObj.data_spc[index,:,:]
359
413
360 #DC channel
414 blocksize = 0
361 dc = numpy.zeros( (nChannels,nHeights), dtype='complex' )
415 #self spectra
362 for index, channel in enumerate(channelIndexList):
416 spc = self.dataOutObj.data_spc[channelIndexList,:,:]
363 dc[index,:] = self.dataOutObj.data_dc[channel,:]
364
365 blocksize += dc.size
366 blocksize += spc.size
417 blocksize += spc.size
367
368 nPairs = 0
369 cspc = None
370
418
371 if pairList == None:
419 cspc = None
372 pairList = self.pairList
420 if pairIndexList != []:
373
421 cspc = self.dataOutObj.data_cspc[pairIndexList,:,:]
374 if (pairList != None) and (self.dataOutObj.data_cspc != None):
375 #cross spectra
376 nPairs = len(pairList)
377 cspc = numpy.zeros( (nPairs,nProfiles,nHeights), dtype='complex' )
378
379 spectraComb = self.dataOutObj.m_ProcessingHeader.spectraComb
380 totalSpectra = len(spectraComb)
381 nchan = self.dataOutObj.nChannels
382 pairIndexList = []
383
384 for pair in pairList: #busco el par en la lista de pares del Spectra Combinations
385 for index in range(0,totalSpectra,2):
386 if pair[0] == spectraComb[index] and pair[1] == spectraComb[index+1]:
387 pairIndexList.append( index/2 - nchan )
388
389 for index, pair in enumerate(pairIndexList):
390 cspc[index,:,:] = self.dataOutObj.data_cspc[pair,:,:]
391 blocksize += cspc.size
422 blocksize += cspc.size
392
393 else:
394 pairList = self.pairList
395 cspc = self.dataOutObj.data_cspc
396 if cspc != None:
397 blocksize += cspc.size
398
423
424 #DC channel
425 dc = None
426 if self.dataOutObj.m_ProcessingHeader.flag_dc:
427 dc = self.dataOutObj.data_dc[channelIndexList,:]
428 blocksize += dc.size
429
430 #Almacenar las combinaciones de canales y cros espectros
431
399 spectraComb = numpy.zeros( (nChannels+nPairs)*2,numpy.dtype('u1'))
432 spectraComb = numpy.zeros( (nChannels+nPairs)*2,numpy.dtype('u1'))
400 i = 0
433 i = 0
401 for val in channelList:
434 for spcChannel in channelIndexList:
402 spectraComb[i] = val
435 spectraComb[i] = spcChannel
403 spectraComb[i+1] = val
436 spectraComb[i+1] = spcChannel
404 i += 2
437 i += 2
405
438
406 if pairList != None:
439 if pairList != None:
@@ -408,21 +441,28 class SpectraProcessor:
408 spectraComb[i] = pair[0]
441 spectraComb[i] = pair[0]
409 spectraComb[i+1] = pair[1]
442 spectraComb[i+1] = pair[1]
410 i += 2
443 i += 2
411
444
445 #######
446
412 self.dataOutObj.data_spc = spc
447 self.dataOutObj.data_spc = spc
413 self.dataOutObj.data_cspc = cspc
448 self.dataOutObj.data_cspc = cspc
414 self.dataOutObj.data_dc = dc
449 self.dataOutObj.data_dc = dc
415 self.dataOutObj.nChannels = nChannels
450 self.dataOutObj.nChannels = nChannels
416 self.dataOutObj.nPairs = nPairs
451 self.dataOutObj.nPairs = nPairs
417
452
418 self.dataOutObj.channelList = channelList
453 self.dataOutObj.channelIndexList = channelIndexList
419
454
420 self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
455 self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
421 self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPairs
456 self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPairs
422 self.dataOutObj.m_SystemHeader.numChannels = nChannels
457 self.dataOutObj.m_SystemHeader.numChannels = nChannels
423 self.dataOutObj.nChannels = nChannels
458 self.dataOutObj.nChannels = nChannels
424 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
459 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
425
460
461 if cspc == None:
462 self.dataOutObj.m_ProcessingHeader.flag_dc = False
463 if dc == None:
464 self.dataOutObj.m_ProcessingHeader.flag_cpsc = False
465
426 def selectHeightsByValue(self, minHei, maxHei):
466 def selectHeightsByValue(self, minHei, maxHei):
427 """
467 """
428 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
468 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
Show file before | Show file after | Hide comments
@@ -22,7 +22,7 class VoltageProcessor:
22
22
23 dataInObj = None
23 dataInObj = None
24 dataOutObj = None
24 dataOutObj = None
25
25
26 integratorObjIndex = None
26 integratorObjIndex = None
27 decoderObjIndex = None
27 decoderObjIndex = None
28 profSelectorObjIndex = None
28 profSelectorObjIndex = None
@@ -37,17 +37,10 class VoltageProcessor:
37 plotterObjList = []
37 plotterObjList = []
38 m_Voltage= Voltage()
38 m_Voltage= Voltage()
39
39
40 def __init__(self, dataInObj=None, dataOutObj=None):
40 def __init__(self):
41 '''
41 '''
42 Constructor
42 Constructor
43 '''
43 '''
44
45 self.dataInObj = dataInObj
46
47 if dataOutObj == None:
48 self.dataOutObj = Voltage()
49 else:
50 self.dataOutObj = dataOutObj
51
44
52 self.integratorObjIndex = None
45 self.integratorObjIndex = None
53 self.decoderObjIndex = None
46 self.decoderObjIndex = None
@@ -60,22 +53,20 class VoltageProcessor:
60 self.profileSelectorObjList = []
53 self.profileSelectorObjList = []
61 self.writerObjList = []
54 self.writerObjList = []
62 self.plotterObjList = []
55 self.plotterObjList = []
63
64 def setIO(self,inputObject, outputObject):
65
56
66 if not( isinstance(inputObject, Voltage) ):
57 def setup(self, dataInObj=None, dataOutObj=None):
67 print 'InputObject must be an instance from Voltage()'
68 sys.exit(0)
69
58
70 if not( isinstance(outputObject, Voltage) ):
59 self.dataInObj = dataInObj
71 print 'OutputObject must be an instance from Voltage()'
60
72 sys.exit(0)
61 if dataOutObj == None:
62 dataOutObj = Voltage()
73
63
74 self.dataInObj = inputObject
64 dataOutObj.copy(dataInObj)
75 self.dataOutObj = outputObject
65
66 self.dataOutObj = dataOutObj
67
68 return self.dataOutObj
76
69
77 def setup(self):
78 pass
79
70
80 def init(self):
71 def init(self):
81
72
@@ -217,15 +208,18 class VoltageProcessor:
217 self.flipIndex *= -1.
208 self.flipIndex *= -1.
218
209
219 def selectChannels(self, channelList):
210 def selectChannels(self, channelList):
211 pass
212
213 def selectChannelsByIndex(self, channelIndexList):
220 """
214 """
221 Selecciona un bloque de datos en base a canales segun el channelList
215 Selecciona un bloque de datos en base a canales segun el channelIndexList
222
216
223 Input:
217 Input:
224 channelList : lista sencilla de canales a seleccionar por ej. [2,3,7]
218 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
225
219
226 Affected:
220 Affected:
227 self.dataOutObj.data
221 self.dataOutObj.data
228 self.dataOutObj.channelList
222 self.dataOutObj.channelIndexList
229 self.dataOutObj.nChannels
223 self.dataOutObj.nChannels
230 self.dataOutObj.m_ProcessingHeader.totalSpectra
224 self.dataOutObj.m_ProcessingHeader.totalSpectra
231 self.dataOutObj.m_SystemHeader.numChannels
225 self.dataOutObj.m_SystemHeader.numChannels
@@ -237,19 +231,19 class VoltageProcessor:
237 if self.dataOutObj.flagNoData:
231 if self.dataOutObj.flagNoData:
238 return 0
232 return 0
239
233
240 for channel in channelList:
234 for channel in channelIndexList:
241 if channel not in self.dataOutObj.channelList:
235 if channel not in self.dataOutObj.channelIndexList:
242 raise ValueError, "The value %d in channelList is not valid" %channel
236 raise ValueError, "The value %d in channelIndexList is not valid" %channel
243
237
244 nChannels = len(channelList)
238 nChannels = len(channelIndexList)
245
239
246 data = self.dataOutObj.data[channelList,:]
240 data = self.dataOutObj.data[channelIndexList,:]
247
241
248 self.dataOutObj.data = data
242 self.dataOutObj.data = data
249 self.dataOutObj.channelList = channelList
243 self.dataOutObj.channelIndexList = channelIndexList
250 self.dataOutObj.nChannels = nChannels
244 self.dataOutObj.nChannels = nChannels
251
245
252 self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels
246 self.dataOutObj.m_ProcessingHeader.totalSpectra = 0
253 self.dataOutObj.m_SystemHeader.numChannels = nChannels
247 self.dataOutObj.m_SystemHeader.numChannels = nChannels
254 self.dataOutObj.m_ProcessingHeader.blockSize = data.size
248 self.dataOutObj.m_ProcessingHeader.blockSize = data.size
255 return 1
249 return 1
Show file before | Show file after | Hide comments
@@ -30,29 +30,47 class TestSChain():
30
30
31 self.path = "/home/dsuarez/Projects" #1
31 self.path = "/home/dsuarez/Projects" #1
32 self.path = "/Users/jro/Documents/RadarData/EW_Drifts"
32 self.path = "/Users/jro/Documents/RadarData/EW_Drifts"
33 # self.path = "/Users/jro/Documents/RadarData/JULIA"
33 self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
34 # self.startDateTime = datetime.datetime(2007,5,1,15,49,0)
34 # self.startDateTime = datetime.datetime(2007,5,1,15,49,0)
35 # self.endDateTime = datetime.datetime(2007,5,1,23,0,0)
35 # self.endDateTime = datetime.datetime(2007,5,1,23,0,0)
36
36
37 self.startDateTime = datetime.datetime(2011,10,1,0,0,0)
37 self.startDateTime = datetime.datetime(2009,01,1,0,0,0)
38 self.endDateTime = datetime.datetime(2011,12,31,0,20,0)
38 self.endDateTime = datetime.datetime(2009,01,31,0,20,0)
39
40 # self.startDateTime = datetime.datetime(2011,11,1,0,0,0)
41 # self.endDateTime = datetime.datetime(2011,12,31,0,20,0)
42
43
39 self.N = 4
44 self.N = 4
40 self.npts = 8
45 self.npts = 8
41
46
42 def createObjects( self ):
47 def createObjects( self ):
43
48
44 self.voltObj1 = Voltage()
49 self.readerObj = VoltageReader()
45 self.voltObj2 = Voltage()
50 self.voltProcObj = VoltageProcessor()
46 self.specObj1 = Spectra()
51 self.specProcObj = SpectraProcessor()
47
48 self.readerObj = VoltageReader(self.voltObj1)
49 self.voltProcObj = VoltageProcessor(self.voltObj1, self.voltObj2)
50 self.specProcObj = SpectraProcessor(self.voltObj2, self.specObj1)
51
52
52 if not(self.readerObj.setup( self.path, self.startDateTime, self.endDateTime, expLabel='', online =0) ):
53 voltObj1 = self.readerObj.setup(
54 path = self.path,
55 startDateTime = self.startDateTime,
56 endDateTime = self.endDateTime,
57 expLabel = '',
58 online = 0)
59
60 if not(voltObj1):
53 sys.exit(0)
61 sys.exit(0)
54
62
55 self.specProcObj.setup(nFFTPoints=8)
63 voltObj2 = self.voltProcObj.setup(dataInObj = voltObj1)
64
65 specObj1 = self.specProcObj.setup(dataInObj = voltObj2,
66 nFFTPoints = 16)
67
68 # voltObj2 = self.voltProcObj.setup(dataInObj = voltObj1,
69 # dataOutObj = voltObj2)
70 #
71 # specObj1 = self.specProcObj.setup(dataInObj = voltObj2,
72 # dataOutObj =specObj1,
73 # nFFTPoints=16)
56
74
57
75
58 def testSChain( self ):
76 def testSChain( self ):
@@ -63,18 +81,18 class TestSChain():
63
81
64 self.voltProcObj.init()
82 self.voltProcObj.init()
65
83
66 self.voltProcObj.plotData(winTitle='VOLTAGE INPUT', index=1)
84 # self.voltProcObj.plotData(winTitle='VOLTAGE INPUT', index=1)
67
85 #
68 self.voltProcObj.integrator(4)
86 # self.voltProcObj.integrator(4)
69
87 #
70 self.voltProcObj.plotData(winTitle='VOLTAGE AVG', index=2)
88 # self.voltProcObj.plotData(winTitle='VOLTAGE AVG', index=2)
89 #
71
90
72
73 self.specProcObj.init()
91 self.specProcObj.init()
74
92
75 self.specProcObj.integrator(N=2)
93 self.specProcObj.integrator(N=1)
76
94
77 self.specProcObj.plotData(winTitle='Spectra 1', index=3)
95 self.specProcObj.plotData(winTitle='Spectra 1', index=1)
78
96
79
97
80 if self.readerObj.flagNoMoreFiles:
98 if self.readerObj.flagNoMoreFiles:
General Comments 0
You need to be logged in to leave comments. Login now