schain Commit - r1579:8a1b75bc0681 · Jicamarca Repository

Interference from YAGI removed, remHeightsIppInterf added

joabAM -

r1579:8a1b75bc0681

parent child

Context file:

r1579:8a1b75bc0681

Collapse all files

schainpy/model/data/jrodata.py +8 -3

                 dataPP_DOP   = None
                 dataPP_WIDTH = None
                 dataPP_SNR   = None
+                flagProfilesByRange = False
+                nProfilesByRange = None
                 def __init__(self):
                     '''
             class Spectra(JROData):
                 data_outlier = None
+                flagProfilesByRange = False
+                nProfilesByRange = None
                 def __init__(self):
                     '''
                 def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     #print(self.flagDecodeData, pwcode)
                     #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     normFactor = self.nProfiles * self.nIncohInt * self.nCohInt * pwcode * self.windowOfFilter
+                    if self.flagProfilesByRange:
+                        normFactor *= (self.nProfilesByRange/self.nProfilesByRange.max())
                     return normFactor
                 noise_estimation = None
                 GauSPC = None  # Fit gaussian SPC
                 txPower = None
+                flagProfilesByRange = False
+                nProfilesByRange = None
                 def __init__(self):
                     '''

schainpy/model/graphics/jroplot_spectra.py +10 -9

                     data = {}
                     meta = {}
-                    norm = dataOut.nProfiles * dataOut.max_nIncohInt * dataOut.nCohInt  * dataOut.windowOfFilter#*dataOut.nFFTPoints
+                    norm = dataOut.nProfiles * dataOut.max_nIncohInt * dataOut.nCohInt  * dataOut.windowOfFilter
-                    n0 = 10*numpy.log10(dataOut.getNoise()/norm)
+                    n0 = (dataOut.getNoise()/norm)
                     noise = numpy.repeat(n0,(dataOut.nFFTPoints*dataOut.nHeights)).reshape(dataOut.nChannels,dataOut.nFFTPoints,dataOut.nHeights)
+                    noise = 10*numpy.log10(noise)
-                    z = []
+                    z = numpy.zeros((dataOut.nChannels, dataOut.nFFTPoints, dataOut.nHeights))
                     for ch in range(dataOut.nChannels):
-                        if hasattr(dataOut.normFactor,'shape'):
+                        if hasattr(dataOut.normFactor,'ndim'):
-                            z.append(numpy.divide(dataOut.data_spc[ch],dataOut.normFactor[ch]))
+                            if dataOut.normFactor.ndim > 1:
+                                z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor[ch]))
+                            else:
+                                z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor))
                         else:
-                            z.append(numpy.divide(dataOut.data_spc[ch],dataOut.normFactor))
+                            z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor))
-                    z = numpy.asarray(z)
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     spc = 10*numpy.log10(z)
                     #print(dataOut.max_nIncohInt, dataOut.nIncohInt)
                     #print(dataOut.windowOfFilter,dataOut.nCohInt,dataOut.nProfiles,dataOut.max_nIncohInt,dataOut.nIncohInt)
                     norm = dataOut.nProfiles * dataOut.max_nIncohInt * dataOut.nCohInt  * dataOut.windowOfFilter
                     n0 = 10*numpy.log10(dataOut.getNoise()/norm)
                     data['noise'] = n0
                     noise = numpy.repeat(n0,dataOut.nHeights).reshape(dataOut.nChannels,dataOut.nHeights)

schainpy/model/proc/jroproc_parameters.py +2 -1

                         self.dataOut.nIncohInt = self.dataIn.nIncohInt
                         self.dataOut.nFFTPoints = self.dataIn.nFFTPoints
                         self.dataOut.ippFactor = self.dataIn.ippFactor
+                        self.dataOut.flagProfilesByRange = self.dataIn.flagProfilesByRange
+                        self.dataOut.nProfilesByRange = self.dataIn.nProfilesByRange
                         self.dataOut.deltaHeight = self.dataIn.deltaHeight
                         self.dataOut.abscissaList = self.dataIn.getVelRange(1)

schainpy/model/proc/jroproc_spectra.py +33 -2

                     self.dataOut.elevationList = self.dataIn.elevationList
                     self.dataOut.code = self.dataIn.code
                     self.dataOut.nCode = self.dataIn.nCode
+                    self.dataOut.flagProfilesByRange = self.dataIn.flagProfilesByRange
+                    self.dataOut.nProfilesByRange = self.dataIn.nProfilesByRange
                 def __getFft(self):
                 factor = 0.0
                 dataoutliers = None # (CHANNELS, HEIGHTS)
+                _flagProfilesByRange = False
+                _nProfilesByRange = 0
                 def __init__(self):
                     Operation.__init__(self)
                     if n == 1:
                         return self.dataOut
                     self.dataOut.processingHeaderObj.timeIncohInt = timeInterval
-                    #print("nchannels", self.dataOut.nChannels)
+                    if dataOut.flagProfilesByRange == True:
+                        self._flagProfilesByRange = True
                     if self.dataOut.nChannels == 1:
                         self.dataOut.data_cspc = None #si es un solo canal no vale la pena acumular DATOS
                     #print("IN spc:", self.dataOut.data_spc.shape, self.dataOut.data_cspc)
                                                                                             self.dataOut.dataLag_cspc,
                                                                                             self.dataOut.dataLag_dc)
                     self.dataOut.flagNoData = True
+                    if self._flagProfilesByRange:
+                        dataOut.flagProfilesByRange = True
+                        self._nProfilesByRange += dataOut.nProfilesByRange
                     if self.__dataReady:
                         if not self.ByLags:
                                 self.dataOut.data_cspc = numpy.squeeze(avgdata_cspc)
                             self.dataOut.data_dc = avgdata_dc
                             self.dataOut.data_outlier = self.dataOutliers
                         else:
                             self.dataOut.dataLag_spc = avgdata_spc
                         self.dataOut.utctime = avgdatatime
                         self.dataOut.flagNoData = False
+                        dataOut.nProfilesByRange = self._nProfilesByRange
+                        self._nProfilesByRange = 0
+                        self._flagProfilesByRange = False
                         # #update Processing Header:
                         # self.dataOut.processingHeaderObj.nIncohInt =
                 incohInt = 0
                 nOutliers = 0
                 n = None
+                _flagProfilesByRange = False
+                _nProfilesByRange = 0
                 def __init__(self):
                     Operation.__init__(self)
                     if dataOut.flagNoData == True:
                         return dataOut
+                    if dataOut.flagProfilesByRange == True:
+                        self._flagProfilesByRange = True
                     dataOut.flagNoData = True
                     dataOut.processingHeaderObj.timeIncohInt = timeInterval
                     if not self.isConfig:
                                                                                         dataOut.data_dc)
                     self.incohInt += dataOut.nIncohInt
                     if isinstance(dataOut.data_outlier,numpy.ndarray) or isinstance(dataOut.data_outlier,int) or isinstance(dataOut.data_outlier, float):
                         self.nOutliers += dataOut.data_outlier
+                    if self._flagProfilesByRange:
+                        dataOut.flagProfilesByRange = True
+                        self._nProfilesByRange += dataOut.nProfilesByRange
                     if self.__dataReady:
                         #print("prof: ",dataOut.max_nIncohInt,self.__profIndex)
                         dataOut.data_spc = avgdata_spc
                         self.incohInt = 0
                         self.nOutliers = 0
                         self.__profIndex = 0
+                        dataOut.nProfilesByRange = self._nProfilesByRange
+                        self._nProfilesByRange = 0
+                        self._flagProfilesByRange = False
                         #print("IncohInt Done")
                     return dataOut

schainpy/model/proc/jroproc_voltage.py +94 -5

@@ -45,8 +45,7 class VoltageProc(ProcessingUnit):
45	self.dataOut.processingHeaderObj.codeList = self.dataOut.nChannels	45	self.dataOut.processingHeaderObj.codeList = self.dataOut.nChannels
46	self.dataOut.processingHeaderObj.heightList = self.dataOut.heightList	46	self.dataOut.processingHeaderObj.heightList = self.dataOut.heightList
47	self.dataOut.processingHeaderObj.heightResolution = self.dataOut.heightList[1] - self.dataOut.heightList[0]	47	self.dataOut.processingHeaderObj.heightResolution = self.dataOut.heightList[1] - self.dataOut.heightList[0]
48		48
49
50		49
51		50
52	def __updateObjFromAmisrInput(self):	51	def __updateObjFromAmisrInput(self):
@@ -2018,7 +2017,17 class SSheightProfiles2(Operation):
2018	dataOut.processingHeaderObj.ipp = ippSeconds	2017	dataOut.processingHeaderObj.ipp = ippSeconds
2019	dataOut.processingHeaderObj.heightResolution = dataOut.deltaHeight	2018	dataOut.processingHeaderObj.heightResolution = dataOut.deltaHeight
2020	#dataOut.processingHeaderObj.profilesPerBlock = nProfiles	2019	#dataOut.processingHeaderObj.profilesPerBlock = nProfiles
2021		2020
		2021	# # dataOut.data = CH, PROFILES, HEIGHTS
		2022	#print(dataOut.data .shape)
		2023	if dataOut.flagProfilesByRange:
		2024	# #assuming the same remotion for all channels
		2025	aux = [ self.nsamples - numpy.count_nonzero(dataOut.data[0, :, h]==0) for h in range(len(dataOut.heightList))]
		2026	dataOut.nProfilesByRange = numpy.asarray(aux)
		2027	#print(dataOut.nProfilesByRange)
		2028	else:
		2029	dataOut.nProfilesByRange = numpy.ones(len(dataOut.heightList))*dataOut.nProfiles
		2030	print(dataOut.nProfilesByRange)
2022	return dataOut	2031	return dataOut
2023		2032
2024		2033
@@ -2766,9 +2775,9 class removeProfileByFaradayHS(Operation):
2766		2775
2767	if self.__profIndex == self.n:	2776	if self.__profIndex == self.n:
2768	#print("apnd : ",data)	2777	#print("apnd : ",data)
2769	#dataBlock = self.cleanOutliersByBlock()	2778	dataBlock = self.cleanOutliersByBlock()
2770	#dataBlock = self.cleanSpikesFFT2D()	2779	#dataBlock = self.cleanSpikesFFT2D()
2771	dataBlock = self.filterSatsProfiles2()	2780	#dataBlock = self.filterSatsProfiles2()
2772	self.__dataReady = True	2781	self.__dataReady = True
2773		2782
2774	return dataBlock	2783	return dataBlock
@@ -3566,3 +3575,83 class RemoveProfileSats2(Operation):
3566	#print(self.__count_exec)	3575	#print(self.__count_exec)
3567		3576
3568	return dataOut	3577	return dataOut
		3578
		3579
		3580
		3581
		3582	class remHeightsIppInterf(Operation):
		3583
		3584	def __init__(self):
		3585
		3586	self.config = False
		3587
		3588	self.heights_indx = None
		3589	self.heightsList = []
		3590
		3591	self.ipp1 = None
		3592	self.ipp2 = None
		3593	self.tx1 = None
		3594	self.tx2 = None
		3595	self.dh1 = None
		3596
		3597
		3598	def setup(self, dataOut, ipp1=None, ipp2=None, tx1=None, tx2=None, dh1=None,
		3599	idate=None, startH=None, endH=None):
		3600
		3601
		3602	self.ipp1 = ipp1
		3603	self.ipp2 = ipp2
		3604	self.tx1 = tx1
		3605	self.tx2 = tx2
		3606	self.dh1 = dh1
		3607
		3608	_maxIpp1R = dataOut.heightList.max()
		3609
		3610	_n_repeats = int(_maxIpp1R / ipp2)
		3611	_init_hIntf = (tx1 + ipp2/2)+ dh1
		3612	_n_hIntf = int(tx2 / dh1)
		3613
		3614	self.heightsList = [_init_hIntf+n*ipp2 for n in range(_n_repeats) ]
		3615	heiList = dataOut.heightList
		3616	self.heights_indx = [getHei_index(h,h,heiList)[0] for h in self.heightsList]
		3617
		3618	self.heights_indx = [ numpy.asarray([k for k in range(_n_hIntf+2)])+(getHei_index(h,h,heiList)[0] -1) for h in self.heightsList]
		3619
		3620	self.heights_indx = numpy.asarray(self.heights_indx )
		3621	self.config = True
		3622	self.startTime = datetime.datetime.combine(idate,startH)
		3623	self.endTime = datetime.datetime.combine(idate,endH)
		3624	#print(self.startTime, self.endTime)
		3625	#print("nrepeats: ", _n_repeats, " _nH: ",_n_hIntf )
		3626	#print("H interf:",self.heightsList, dataOut.heightList[self.heights_indx] )
		3627
		3628	def run(self, dataOut, ipp1=None, ipp2=None, tx1=None, tx2=None, dh1=None, idate=None,
		3629	startH=None, endH=None):
		3630	#print(locals().values())
		3631	if None in locals().values():
		3632	log.warning('Missing kwargs, invalid values """None""" ', self.name)
		3633	return dataOut
		3634
		3635
		3636	if not self.config:
		3637	self.setup(dataOut, ipp1=ipp1, ipp2=ipp2, tx1=tx1, tx2=tx2, dh1=dh1,
		3638	idate=idate, startH=startH, endH=endH)
		3639
		3640	flagProfilesByRange = False
		3641	currentTime = datetime.datetime.fromtimestamp(dataOut.utctime)
		3642
		3643	if currentTime < self.startTime or currentTime > self.endTime:
		3644	return dataOut
		3645
		3646
		3647	for ch in range(dataOut.data.shape[0]):
		3648
		3649	for hk in self.heights_indx.flatten():
		3650	if dataOut.data.ndim < 3:
		3651	dataOut.data[ch,hk] = 0 + 0j
		3652	else:
		3653	dataOut.data[ch,:,hk] = 0 + 0j
		3654
		3655	dataOut.flagProfilesByRange = True
		3656
		3657	return dataOut 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