schain-jc Commit - r232:13e5ede6a371

Miguel Valdez -

r232:13e5ede6a371

parent child

Context file:

r232:13e5ede6a371

schainpy/model/jrodata.py +15 -2

                 code = None
-                flagDecodeData = True #asumo q la data esta decodificada
+                flagDecodeData = False #asumo q la data no esta decodificada
-                flagDeflipData = True #asumo q la data esta sin flip
+                flagDeflipData = False #asumo q la data no esta sin flip
                 flagShiftFFT = False
                     self.blocksize = None
+                    self.flagDecodeData = False #asumo q la data no esta decodificada
+                    self.flagDeflipData = False #asumo q la data no esta sin flip
+                    self.flagShiftFFT = False
                 def getNoisebyHildebrand(self):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     self.wavelength = None
+                    self.flagDecodeData = False #asumo q la data no esta decodificada
+                    self.flagDeflipData = False #asumo q la data no esta sin flip
+                    self.flagShiftFFT = False
                 def getNoisebyHildebrand(self):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon

schainpy/model/jrodataIO.py +15 -2

                         self.dataOut.flagShiftFFT = False
                         if self.processingHeaderObj.code != None:
                             self.dataOut.nCode = self.processingHeaderObj.nCode
                             self.dataOut.nBaud = self.processingHeaderObj.nBaud
                         self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
+                        self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada
+                        self.dataOut.flagDeflipData = False #asumo q la data no esta sin flip
+                        self.dataOut.flagShiftFFT = False
             #            self.updateDataHeader()
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints
-                    self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
             #        self.profileIndex += 1
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
+                    self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
+                    self.dataOut.flagDecodeData = True #asumo q la data no esta decodificada
+                    self.dataOut.flagDeflipData = True #asumo q la data no esta sin flip
                     return self.dataOut.data_spc

schainpy/model/jroheaderIO.py +1 -1

                         self.profilesPerBlock = int(header['nProfilesperBlock'][0])
                         self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
                         self.nWindows = int(header['nNumWindows'][0])
-                        self.processFlags = int(header['nProcessFlags'])
+                        self.processFlags = header['nProcessFlags']
                         self.nCohInt = int(header['nCoherentIntegrations'][0])
                         self.nIncohInt = int(header['nIncoherentIntegrations'][0])
                         self.totalSpectra = int(header['nTotalSpectra'][0])

schainpy/model/jroplot.py +13 -8

                     x = dataOut.getFreqRange(1)
                     y = dataOut.getHeiRange()
                     z = 10.*numpy.log10(dataOut.data_spc[:,:,:])
+                    z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(numpy.abs(z), axis=1)
                     noise = dataOut.getNoise()
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     z = 10.*numpy.log10(dataOut.data_spc[channelIndexList,:,:])
+                    z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     noise = dataOut.getNoise()
                         if zmin == None: zmin = numpy.nanmin(avg)*0.9
                         if zmax == None: zmax = numpy.nanmax(avg)*0.9
+                        self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.__isConfig = True
                     thisDatetime = dataOut.datatime
                     self.draw()
                     if save:
-                        date = thisDatetime.strftime("%Y%m%d")
                         if figfile == None:
-                            figfile = self.getFilename(name = date)
+                            figfile = self.getFilename(name = self.name)
                         self.saveFigure(figpath, figfile)
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = 10.*numpy.log10(dataOut.data_spc[channelIndexList,:,:])
+                    z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     noise = dataOut.getNoise()
                 def setup(self, idfigure, nplots, wintitle):
+                    self.nplots = nplots
                     self.createFigure(idfigure, wintitle)
                     nrow,ncol = self.getSubplots()
                     for i in range(nplots):
                         self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
-                    self.nplots = nplots
                 def run(self, dataOut, idfigure, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False, filename=None):
                             channelIndexList.append(dataOut.channelList.index(channel))
                     x = dataOut.heightList
-                    y = dataOut.data[channelList,:] * numpy.conjugate(dataOut.data[channelList,:])
+                    y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
                     y = y.real
-                    noise = dataOut.getNoise()
                     if not self.__isConfig:
-                        nplots = len(channelList)
+                        nplots = len(channelIndexList)
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
-                        title = "Channel %d: %4.2fdB" %(i, noise[i])
+                        title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         ychannel = y[i,:]
                         axes.pline(x, ychannel,

schainpy/model/jroprocessing.py +104 -175

@@ -62,7 +62,7 class ProcessingUnit:
62	def operation(self, **kwargs):	62	def operation(self, **kwargs):
63		63
64	"""	64	"""
65	Operacion directa sobre la data (dataout.data). Es necesario actualizar los valores de los	65	Operacion directa sobre la data (dataOut.data). Es necesario actualizar los valores de los
66	atributos del objeto dataOut	66	atributos del objeto dataOut
67		67
68	Input:	68	Input:
@@ -348,23 +348,10 class VoltageProc(ProcessingUnit):
348	return 1	348	return 1
349		349
350		350
351	def filterByHeights(self, window):
352	deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
353
354	if window == None:
355	window = self.dataOut.radarControllerHeaderObj.txA / deltaHeight
356
357	newdelta = deltaHeight * window
358	r = self.dataOut.data.shape[1] % window
359	buffer = self.dataOut.data[:,0:self.dataOut.data.shape[1]-r]
360	buffer = buffer.reshape(self.dataOut.data.shape[0],self.dataOut.data.shape[1]/window,window)
361	buffer = numpy.sum(buffer,2)
362	self.dataOut.data = buffer
363	self.dataOut.heightList = numpy.arange(self.dataOut.heightList[0],newdelta*self.dataOut.nHeights/window,newdelta)
364
365
366	class CohInt(Operation):	351	class CohInt(Operation):
367		352
		353	__isConfig = False
		354
368	__profIndex = 0	355	__profIndex = 0
369	__withOverapping = False	356	__withOverapping = False
370		357
@@ -539,10 +526,10 class CohInt(Operation):
539		526
540	return avgdata, avgdatatime	527	return avgdata, avgdatatime
541		528
542	def run(self, dataOut, n=None, timeInterval=None, overlapping=False):	529	def run(self, dataOut, **kwargs):
543		530
544	if not self.__isConfig:	531	if not self.__isConfig:
545	self.setup(n, ~~timeInterval~~, ~~overlapping~~)	532	self.setup(**kwargs)
546	self.__isConfig = True	533	self.__isConfig = True
547		534
548	avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)	535	avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
@@ -557,6 +544,101 class CohInt(Operation):
557	dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt	544	dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
558	dataOut.flagNoData = False	545	dataOut.flagNoData = False
559		546
		547	class Decoder(Operation):
		548
		549	__isConfig = False
		550	__profIndex = 0
		551
		552	code = None
		553
		554	nCode = None
		555	nBaud = None
		556
		557	def __init__(self):
		558
		559	self.__isConfig = False
		560
		561	def setup(self, code):
		562
		563	self.__profIndex = 0
		564
		565	self.code = code
		566
		567	self.nCode = len(code)
		568	self.nBaud = len(code[0])
		569
		570	def convolutionInFreq(self, data):
		571
		572	ndata = data.shape[1]
		573	newcode = numpy.zeros(ndata)
		574	newcode[0:self.nBaud] = self.code[self.__profIndex]
		575
		576	fft_data = numpy.fft.fft(data, axis=1)
		577	fft_code = numpy.conj(numpy.fft.fft(newcode))
		578	fft_code = fft_code.reshape(1,len(fft_code))
		579
		580	# conv = fft_data.copy()
		581	# conv.fill(0)
		582
		583	conv = fft_data*fft_code
		584
		585	data = numpy.fft.ifft(conv,axis=1)
		586
		587	datadec = data[:,:-self.nBaud+1]
		588	ndatadec = ndata - self.nBaud + 1
		589
		590	if self.__profIndex == self.nCode:
		591	self.__profIndex = 0
		592
		593	self.__profIndex += 1
		594
		595	return ndatadec, datadec
		596
		597
		598	def convolutionInTime(self, data):
		599
		600	nchannel = data.shape[1]
		601	newcode = self.code[self.__profIndex]
		602
		603	datadec = data.copy()
		604
		605	for i in range(nchannel):
		606	datadec[i,:] = numpy.correlate(data[i,:], newcode)
		607
		608	ndatadec = ndata - self.nBaud + 1
		609
		610	if self.__profIndex == self.nCode:
		611	self.__profIndex = 0
		612
		613	self.__profIndex += 1
		614
		615	return ndatadec, datadec
		616
		617	def run(self, dataOut, code=None, mode = 0):
		618
		619	if not self.__isConfig:
		620
		621	if code == None:
		622	code = dataOut.code
		623
		624	self.setup(code)
		625	self.__isConfig = True
		626
		627	if mode == 0:
		628	ndatadec, datadec = self.convolutionInFreq(data)
		629
		630	if mode == 1:
		631	ndatadec, datadec = self.convolutionInTime(data)
		632
		633	dataOut.data = datadec
		634
		635	dataOut.heightList = dataOut.heightList[0:ndatadec+1]
		636
		637	dataOut.flagDecodeData = True #asumo q la data no esta decodificada
		638
		639	# dataOut.flagDeflipData = True #asumo q la data no esta sin flip
		640
		641
560		642
561	class SpectraProc(ProcessingUnit):	643	class SpectraProc(ProcessingUnit):
562		644
@@ -606,7 +688,7 class SpectraProc(ProcessingUnit):
606	self.buffer	688	self.buffer
607	self.dataOut.flagNoData	689	self.dataOut.flagNoData
608	"""	690	"""
609	fft_volt = numpy.fft.fft(self.buffer,axis=1)/~~numpy~~.~~sqrt~~(~~self~~.~~dataOut~~.~~nFFTPoints~~)	691	fft_volt = numpy.fft.fft(self.buffer,axis=1)
610	dc = fft_volt[:,0,:]	692	dc = fft_volt[:,0,:]
611		693
612	#calculo de self-spectra	694	#calculo de self-spectra
@@ -635,6 +717,8 class SpectraProc(ProcessingUnit):
635		717
636	def init(self, nFFTPoints=None, pairsList=None):	718	def init(self, nFFTPoints=None, pairsList=None):
637		719
		720	self.dataOut.flagNoData = True
		721
638	if self.dataIn.type == "Spectra":	722	if self.dataIn.type == "Spectra":
639	self.dataOut.copy(self.dataIn)	723	self.dataOut.copy(self.dataIn)
640	return	724	return
@@ -660,7 +744,7 class SpectraProc(ProcessingUnit):
660	dtype='complex')	744	dtype='complex')
661		745
662		746
663	self.buffer[:,self.profIndex,:] = self.dataIn.data	747	self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
664	self.profIndex += 1	748	self.profIndex += 1
665		749
666	if self.firstdatatime == None:	750	if self.firstdatatime == None:
@@ -988,158 +1072,3 class IncohInt(Operation):
988	dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints	1072	dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints
989	dataOut.flagNoData = False	1073	dataOut.flagNoData = False
990		1074
	No newline at end of file
991
992	class ProfileSelector(Operation):
993
994	profileIndex = None
995	# Tamanho total de los perfiles
996	nProfiles = None
997
998	def __init__(self):
999
1000	self.profileIndex = 0
1001
1002	def incIndex(self):
1003	self.profileIndex += 1
1004
1005	if self.profileIndex >= self.nProfiles:
1006	self.profileIndex = 0
1007
1008	def isProfileInRange(self, minIndex, maxIndex):
1009
1010	if self.profileIndex < minIndex:
1011	return False
1012
1013	if self.profileIndex > maxIndex:
1014	return False
1015
1016	return True
1017
1018	def isProfileInList(self, profileList):
1019
1020	if self.profileIndex not in profileList:
1021	return False
1022
1023	return True
1024
1025	def run(self, dataOut, profileList=None, profileRangeList=None):
1026
1027	self.nProfiles = dataOut.nProfiles
1028
1029	if profileList != None:
1030	if not(self.isProfileInList(profileList)):
1031	dataOut.flagNoData = True
1032	else:
1033	dataOut.flagNoData = False
1034	self.incIndex()
1035	return 1
1036
1037
1038	elif profileRangeList != None:
1039	minIndex = profileRangeList[0]
1040	maxIndex = profileRangeList[1]
1041	if not(self.isProfileInRange(minIndex, maxIndex)):
1042	dataOut.flagNoData = True
1043	else:
1044	dataOut.flagNoData = False
1045	self.incIndex()
1046	return 1
1047	else:
1048	raise ValueError, "ProfileSelector needs profileList or profileRangeList"
1049
1050	return 0
1051
1052	class Decoder:
1053
1054	data = None
1055	profCounter = None
1056	code = None
1057	ncode = None
1058	nbaud = None
1059	codeIndex = None
1060	flag = False
1061
1062	def __init__(self):
1063
1064	self.data = None
1065	self.ndata = None
1066	self.profCounter = 1
1067	self.codeIndex = 0
1068	self.flag = False
1069	self.code = None
1070	self.ncode = None
1071	self.nbaud = None
1072	self.__isConfig = False
1073
1074	def convolutionInFreq(self, data, ndata):
1075
1076	newcode = numpy.zeros(ndata)
1077	newcode[0:self.nbaud] = self.code[self.codeIndex]
1078
1079	self.codeIndex += 1
1080
1081	fft_data = numpy.fft.fft(data, axis=1)
1082	fft_code = numpy.conj(numpy.fft.fft(newcode))
1083	fft_code = fft_code.reshape(1,len(fft_code))
1084
1085	conv = fft_data.copy()
1086	conv.fill(0)
1087
1088	conv = fft_data*fft_code
1089
1090	data = numpy.fft.ifft(conv,axis=1)
1091	self.data = data[:,:-self.nbaud+1]
1092	self.flag = True
1093
1094	if self.profCounter == self.ncode:
1095	self.profCounter = 0
1096	self.codeIndex = 0
1097
1098	self.profCounter += 1
1099
1100	def convolutionInTime(self, data, ndata):
1101
1102	nchannel = data.shape[1]
1103	newcode = self.code[self.codeIndex]
1104	self.codeIndex += 1
1105	conv = data.copy()
1106	for i in range(nchannel):
1107	conv[i,:] = numpy.correlate(data[i,:], newcode)
1108
1109	self.data = conv
1110	self.flag = True
1111
1112	if self.profCounter == self.ncode:
1113	self.profCounter = 0
1114	self.codeIndex = 0
1115
1116	self.profCounter += 1
1117
1118	def run(self, dataOut, code=None, mode = 0):
1119
1120	if not(self.__isConfig):
1121	if code == None:
1122	code = dataOut.radarControllerHeaderObj.code
1123	# code = dataOut.code
1124
1125	ncode, nbaud = code.shape
1126	self.code = code
1127	self.ncode = ncode
1128	self.nbaud = nbaud
1129	self.__isConfig = True
1130
1131	ndata = dataOut.data.shape[1]
1132
1133	if mode == 0:
1134	self.convolutionInFreq(dataOut.data, ndata)
1135
1136	if mode == 1:
1137	self.convolutionInTime(dataOut.data, ndata)
1138
1139	self.ndata = ndata - self.nbaud + 1
1140
1141	dataOut.data = self.data
1142
1143	dataOut.heightList = dataOut.heightList[:self.ndata]
1144
1145	dataOut.flagNoData = False No newline at end of file

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages