schain Commit - r1307:7a6e3ce2f2d5 · Jicamarca Repository

prueba de con ancho espectral y adicion de snr

avaldez -

r1307:7a6e3ce2f2d5

parent child

Context file:

r1307:7a6e3ce2f2d5

schainpy/model/io/jroIO_simulator.py +12 -26

@@ -354,41 +354,27 class SimulatorReader(JRODataReader, ProcessingUnit):
354	InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps](math.sin( self.fAngle)5)	354	InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps](math.sin( self.fAngle)5)
355	InBuffer=InBuffer	355	InBuffer=InBuffer
356	self.datablock[i][k]= InBuffer	356	self.datablock[i][k]= InBuffer
357	#plot_cts(InBuffer,H0=H0,DH0=DH0)	357
358	#wave_fft(x=InBuffer,plot_show=True)
359	#time.sleep(1)
360	#················DOPPLER SIGNAL...............................................	358	#················DOPPLER SIGNAL...............................................
361	time_vec = numpy.linspace(0,(prof_gen-1)ippSec,int(prof_gen))+self.nReadBlocksippSecprof_gen+(self.nReadFiles-1)ippSec*prof_gen	359	time_vec = numpy.linspace(0,(prof_gen-1)ippSec,int(prof_gen))+self.nReadBlocksippSecprof_gen+(self.nReadFiles-1)ippSec*prof_gen
362	fd = Fdoppler #+(600.0/120)*self.nReadBlocks	360	fd = Fdoppler #+(600.0/120)*self.nReadBlocks
363	d_signal = Adopplernumpy.array(numpy.exp(1.0j2.0math.pifd*time_vec),dtype=numpy.complex64)	361	d_signal = Adopplernumpy.array(numpy.exp(1.0j2.0math.pifd*time_vec),dtype=numpy.complex64)
364	#·············Señal con ancho espectral····················	362	#·············Señal con ancho espectral····················
365	#specw_sig = numpy.zeros(int(prof_gen),dtype=complex)	363	#specw_sig = numpy.linspace(-149,150,300)
366	#specw_sig.real[200:200+100] = 1*numpy.ones(100)	364	#w = 8
367	#specw_sig.imag[200:200+100] = 1*numpy.ones(100)	365	#A = 20
368	# w=2	366	#specw_sig = specw_sig/w
369	specw_sig = numpy.~~linspace~~(-~~149~~,~~150~~,~~300~~)	367	#specw_sig = numpy.sinc(specw_sig)
370	w = 3	368	#specw_sig = A*numpy.array(specw_sig,dtype=numpy.complex64)
371	A = 10
372	specw_sig = specw_sig/w
373	specw_sig = numpy.sinc(specw_sig)
374	specw_sig = A*numpy.array(specw_sig,dtype=numpy.complex64)
375	#·················· DATABLOCK + DOPPLER····················	369	#·················· DATABLOCK + DOPPLER····················
376	HD=int(Hdoppler/self.AcqDH_0)	370	HD=int(Hdoppler/self.AcqDH_0)
377	for i in range(12):	371	for i in range(12):
378	self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ d_signal# RESULT	372	self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ d_signal# RESULT
379		373	#·················· DATABLOCK + DOPPLER*Sinc(x)····················
380	HD=int(Hdoppler/self.AcqDH_0)	374	#HD=int(Hdoppler/self.AcqDH_0)
381	HD=int(HD/2)	375	#HD=int(HD/2)
382	for i in range(12):	376	#for i in range(12):
383	self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT	377	# self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT
384
385	'''
386	a= numpy.zeros(10)
387	for i in range(10):
388	a[i]=i+self.nReadBlocks+20
389	for i in a:
390	self.datablock[0,:,int(i)]=self.datablock[0,:,int(i)]+ d_signal # RESULT
391	'''
392		378
393	def readBlock(self):	379	def readBlock(self):
394		380

schainpy/model/proc/jroproc_voltage.py +27 -21

                                                        n,
                                                        dataOut.nHeights),
                                                       dtype='complex')
-                    self.noise  = numpy.zeros([self.__nch,self.__nHeis])
+                    #self.noise  = numpy.zeros([self.__nch,self.__nHeis])
-                    for i in range(self.__nch):
+                    #for i in range(self.__nch):
-                        self.noise[i]=dataOut.getNoise(channel=i)
+                    #    self.noise[i]=dataOut.getNoise(channel=i)
                 def putData(self,data):
                     '''
                     self.__profIndex      += 1
                     return
-                def pushData(self):
+                def pushData(self,dataOut):
                     '''
                     Return the PULSEPAIR and the profiles used in the operation
                     Affected :  self.__profileIndex
                     '''
                     if self.removeDC==True:
                         mean    = numpy.mean(self.__buffer,1)
                         tmp     = mean.reshape(self.__nch,1,self.__nHeis)
                     #angle            = numpy.angle(numpy.sum(pair1,1))*180/(math.pi)
                     data_velocity    = (-1.0*self.lambda_/(4*math.pi*self.ippSec))*numpy.angle(lag_1)#self.ippSec*self.nCohInt
+                    self.noise  = numpy.zeros([self.__nch,self.__nHeis])
+                    for i in range(self.__nch):
+                        self.noise[i]=dataOut.getNoise(channel=i)
                     lag_0            = lag_0.real/(self.n)
                     lag_1            = lag_1/(self.n-1)
                     R1               = numpy.abs(lag_1)
                     S                = (lag_0-self.noise)
-                    #k = R1/S
-                    #k = 1-k
+                    data_snrPP       = S/self.noise
-                    #k =numpy.absolute(k)
+                    data_snrPP       = numpy.where(data_snrPP<0,1,data_snrPP)
-                    #k =numpy.sqrt(k)
                     L                = S/R1
-                    #print("L",L[0])
                     L                = numpy.where(L<0,1,L)
                     L                = numpy.log(L)
                     tmp              = numpy.sqrt(numpy.absolute(L))
                     data_specwidth   = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec))*tmp*numpy.sign(L)
                     #data_specwidth   = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec))*k
                     n                = self.__profIndex
                     self.__buffer    = numpy.zeros((self.__nch, self.__nProf,self.__nHeis),  dtype='complex')
                     self.__profIndex = 0
-                    return data_intensity,data_velocity,data_specwidth,n
+                    return data_intensity,data_velocity,data_snrPP,data_specwidth,n
-                def pulsePairbyProfiles(self,data):
+                def pulsePairbyProfiles(self,dataOut):
                     self.__dataReady     =  False
                     data_intensity       =  None
                     data_velocity        =  None
                     data_specwidth       =  None
-                    self.putData(data)
+                    data_snrPP           =  None
+                    self.putData(data=dataOut.data)
                     if self.__profIndex  == self.n:
                         #self.noise  = numpy.zeros([self.__nch,self.__nHeis])
                         #for i in range(self.__nch):
                         #    self.noise[i]=data.getNoise(channel=i)
                         #print(self.noise.shape)
-                        data_intensity, data_velocity,data_specwidth, n   = self.pushData()
+                        data_intensity, data_velocity,data_snrPP,data_specwidth, n   = self.pushData(dataOut=dataOut)
                         self.__dataReady                   = True
-                    return data_intensity, data_velocity,data_specwidth
+                    return data_intensity, data_velocity,data_snrPP,data_specwidth
-                def pulsePairOp(self, data, datatime= None):
+                def pulsePairOp(self, dataOut, datatime= None):
                     if self.__initime == None:
                         self.__initime = datatime
+                    #print("hola")
-                    data_intensity, data_velocity,data_specwidth = self.pulsePairbyProfiles(data)
+                    data_intensity, data_velocity,data_snrPP,data_specwidth = self.pulsePairbyProfiles(dataOut)
                     self.__lastdatatime           = datatime
                     if data_intensity is None:
-                        return None, None,None, None
+                        return None, None,None,None,None
                     avgdatatime    = self.__initime
                     deltatime      = datatime - self.__lastdatatime
                     self.__initime = datatime
-                    return data_intensity, data_velocity,data_specwidth,avgdatatime
+                    return data_intensity, data_velocity,data_snrPP,data_specwidth,avgdatatime
                 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
                     if not self.isConfig:
                         self.setup(dataOut = dataOut, n    = n , removeDC=removeDC , **kwargs)
                         self.isConfig   = True
-                    data_intensity, data_velocity,data_specwidth, avgdatatime = self.pulsePairOp(dataOut.data, dataOut.utctime)
+                    data_intensity, data_velocity,data_snrPP,data_specwidth, avgdatatime = self.pulsePairOp(dataOut, dataOut.utctime)
                     dataOut.flagNoData                         = True
                     if self.__dataReady:
                         dataOut.nCohInt        *= self.n
                         dataOut.data_intensity  = data_intensity #valor para intensidad
                         dataOut.data_velocity   = data_velocity  #valor para velocidad
+                        dataOut.data_snrPP      = data_snrPP     # valor para snr
                         dataOut.data_specwidth  = data_specwidth
                         dataOut.PRFbyAngle      = self.n         #numero de PRF*cada angulo rotado que equivale a un tiempo.
                         dataOut.utctime         = avgdatatime

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