schain Commit - r1244:464f48b8a1f9 · Jicamarca Repository

Correcion de plot eje, graficos centrados, seleccion de ploteo real,imag, abs por defecto, pruebas integrando5 min

avaldez -

r1244:464f48b8a1f9

parent child

Context file:

r1244:464f48b8a1f9

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

                 def getFmax(self):
                     PRF = 1. / (self.ippSeconds * self.nCohInt)
                     fmax = PRF
                     return fmax
                     noise = numpy.zeros(self.nChannels)
                     for channel in range(self.nChannels):
-                        #print "confuse",self.data_spc.dtype
                         daux = self.data_spc[channel,
                                              xmin_index:xmax_index, ymin_index:ymax_index]
-                        #print "HI3.0",(daux.dtype),daux.shape
                         noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return noise
                     return freqrange
                 def getAcfRange(self, extrapoints=0):
-                    #print "miay",self.ippFactor
+                    deltafreq = 10. / (  self.getFmax() / (self.nFFTPoints * self.ippFactor)   )
-                    deltafreq = 10. / (self.getFmax() / (self.nFFTPoints * self.ippFactor))
-                    #print deltafreq
                     freqrange = deltafreq * \
                         (numpy.arange(self.nFFTPoints + extrapoints) -
                          self.nFFTPoints / 2.) - deltafreq / 2
                 def getFreqRange(self, extrapoints=0):
                     deltafreq = self.getFmax() / (self.nFFTPoints * self.ippFactor)
+                    #print "deltafreq", deltafreq
                     freqrange = deltafreq * \
                         (numpy.arange(self.nFFTPoints + extrapoints) -
                          self.nFFTPoints / 2.) - deltafreq / 2
+                    #print "freqrange",freqrange
                     return freqrange
                 def getVelRange(self, extrapoints=0):

schainpy/model/graphics/jroplot_spectra.py +2 -17

                         folder=None, username=None, password=None,
                         xaxis="frequency"):
                     channel0      =  channel
                     nSamples      =  nSamples
                     resFactor     =  resolutionFactor
                     shape        =  dataOut.data_acf.shape
                     hei_index    =  numpy.arange(shape[2])
                     hei_plot     =  numpy.arange(nSamples)*resFactor
-                    #print hei_plot
-                    #import matplotlib.pyplot as plt
-                    #c=z[0,:,0]*15+15
-                    #plt.plot(c)
-                    #plt.show()
-                    #print "HOLA#
                     if nSampleList    is not  None:
                         for nsample in nSampleList:
                     #escalamiento  -1 a 1 a resolucion (factor de resolucion en altura)* deltaHeight
                     min = numpy.min(z[0,:,0])
                     max =numpy.max(z[0,:,0])
                     for i in range(shape[0]):
                         for j in range(shape[2]):
                             z[i,:,j]= (((z[i,:,j]-min)/(max-min))*deltaHeight*resFactor + j*deltaHeight)
-                            #z[i,:,j]= (z[i,:,j]+1.0)*deltaHeight*dataOut.step/2.0 + j*deltaHeight*dataOut.step
-                    #print deltaHeight
-                    #print resFactor
-                    #print numpy.max(z[0,:,0])
-                    #import matplotlib.pyplot as plt
-                    #plt.plot((z[0,:,0])*deltaHeight)
-                    #plt.show()
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange()/1000.
                         ylabel = "Power (dB)"
                     elif xaxis == "time":
-                        x = dataOut.getAcfRange()
+                        delta= dataOut.getAcfRange()[1]-dataOut.getAcfRange()[0]
+                        x = dataOut.getAcfRange()+delta/2.0
                         zdB = z[channel0,:,hei_plot]
                         xlabel = "Time (ms)"
                         ylabel = "ACF"

schainpy/model/proc/jroproc_spectra.py +10 -13

                 def __updateSpecFromVoltage(self):
-                    self.dataOut.timeZone = self.dataIn.timeZone
+                    self.dataOut.timeZone    = self.dataIn.timeZone
-                    self.dataOut.dstFlag = self.dataIn.dstFlag
+                    self.dataOut.dstFlag     = self.dataIn.dstFlag
-                    self.dataOut.errorCount = self.dataIn.errorCount
+                    self.dataOut.errorCount  = self.dataIn.errorCount
-                    self.dataOut.useLocalTime = self.dataIn.useLocalTime
+                    self.dataOut.useLocalTime= self.dataIn.useLocalTime
                     try:
                         self.dataOut.processingHeaderObj = self.dataIn.processingHeaderObj.copy()
                     except:
                         pass
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
-                    self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
+                    self.dataOut.systemHeaderObj          = self.dataIn.systemHeaderObj.copy()
-                    self.dataOut.channelList = self.dataIn.channelList
+                    self.dataOut.channelList              = self.dataIn.channelList
-                    self.dataOut.heightList = self.dataIn.heightList
+                    self.dataOut.heightList               = self.dataIn.heightList
-                    #print self.dataOut.heightList.shape,"spec4"
+                    self.dataOut.dtype                    = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
-                    self.dataOut.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     self.dataOut.nBaud = self.dataIn.nBaud
                     self.dataOut.nCode = self.dataIn.nCode
                     self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
                     self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
-                    self.dataOut.step = self.dataIn.step #
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
-                        print "hi",self.dataOut.ippSeconds
                         if shift_fft:
                             #desplaza a la derecha en el eje 2 determinadas posiciones
                             shift = int(self.dataOut.nFFTPoints/2)
                         if self.buffer is None:
                             self.buffer = numpy.zeros((self.dataIn.nChannels,
                                                        nProfiles,
-                                                       self.dataIn.heightList.shape[0]),
+                                                       self.dataIn.heightList.shape[0]),#update heightlist
                                                       dtype='complex')

schainpy/model/proc/jroproc_spectra_acf.py +10 -17

                     self.dataOut.blockSize = blocksize
                     self.dataOut.flagShiftFFT = True
-                def run(self, nProfiles=None, nFFTPoints=None, pairsList=[], code=None, nCode=1, nBaud=1):
+                def run(self, nProfiles=None, nFFTPoints=None, pairsList=[], code=None, nCode=1, nBaud=1,real= None, imag=None):
                     self.dataOut.flagNoData = True
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
-                        #print "hi",self.dataOut.ippSeconds
+                        spc         =  self.dataOut.data_spc
+                        data        =  numpy.fft.ifft(spc, axis=1)
-                        spc         = self.dataOut.data_spc
+                        data        =  numpy.fft.fftshift(data, axes=(1,))
-                        data        = numpy.fft.ifft(spc, axis=1)
+                        acf         =  numpy.abs(data)     #  Autocorrelacion LLAMAR A ESTE VALOR ACF
-                        data        = numpy.fft.fftshift(data, axes=(1,))
+                        if real:
-                        acf         = numpy.abs(data) # Autocorrelacion LLAMAR A ESTE VALOR ACF
+                            acf     = data.real
-                        #acf         = data.imag
+                        if imag:
-                        shape       = acf.shape #nchannels, nprofiles, nsamples
+                            acf     = data.imag
+                        shape       =  acf.shape            #  nchannels, nprofiles, nsamples
-                        #import matplotlib.pyplot as plt
-                        #plt.plot(acf[0,:,0] / numpy.max(numpy.abs(acf[0,:,0])))
-                        #plt.show()
                         # Normalizando
                         for i in range(shape[0]):
                             for j in range(shape[2]):
                                 acf[i,:,j]= acf[i,:,j] / numpy.max(numpy.abs(acf[i,:,j]))
-                        #import matplotlib.pyplot as plt
-                        #plt.plot(acf[0,:,0])
-                        #plt.show()
                         self.dataOut.data_acf = acf
                         return True

schainpy/model/proc/jroproc_voltage.py +26 -29

             class SSheightProfiles(Operation):
-                step        = None
+                step          = None
-                nsamples    = None
+                nsamples      = None
-                bufferShape = None
+                bufferShape   = None
-                profileShape= None
+                profileShape  = None
-                sshProfiles = None
+                sshProfiles   = None
-                profileIndex= None
+                profileIndex  = None
                 def __init__(self, **kwargs):
                     if step == None and nsamples == None:
                         raise ValueError, "step or nheights should be specified ..."
-                    self.step        = step
+                    self.step         = step
-                    self.nsamples    = nsamples
+                    self.nsamples     = nsamples
-                    self.__nChannels = dataOut.nChannels
+                    self.__nChannels  = dataOut.nChannels
-                    self.__nProfiles = dataOut.nProfiles
+                    self.__nProfiles  = dataOut.nProfiles
-                    self.__nHeis     = dataOut.nHeights
+                    self.__nHeis      = dataOut.nHeights
-                    shape            = dataOut.data.shape #nchannels, nprofiles, nsamples
+                    shape             = dataOut.data.shape #nchannels, nprofiles, nsamples
-                    #print  "shape",shape
-                    #last test
-                    residue =  (shape[1] - self.nsamples) % self.step
+                    residue     =  (shape[1] - self.nsamples) % self.step
                     if residue != 0:
                         print "The residue is %d, step=%d should be multiple of %d to avoid loss of %d samples"%(residue,step,shape[1] - self.nsamples,residue)
-                    deltaHeight     = dataOut.heightList[1] - dataOut.heightList[0]
+                    deltaHeight      =  dataOut.heightList[1] - dataOut.heightList[0]
-                    numberProfile   = self.nsamples
+                    numberProfile    =  self.nsamples
-                    numberSamples   = (shape[1] - self.nsamples)/self.step
+                    numberSamples    =  (shape[1] - self.nsamples)/self.step
                     print "New number of profile: %d, number of height: %d, Resolution %d Km"%(numberProfile,numberSamples,deltaHeight*self.step)
                     self.bufferShape  = shape[0], numberSamples, numberProfile  # nchannels, nsamples , nprofiles
                     self.profileShape = shape[0], numberProfile, numberSamples  # nchannels, nprofiles, nsamples
-                    self.buffer      = numpy.zeros(self.bufferShape , dtype=numpy.complex)
+                    self.buffer       = numpy.zeros(self.bufferShape , dtype=numpy.complex)
-                    self.sshProfiles = numpy.zeros(self.profileShape, dtype=numpy.complex)
+                    self.sshProfiles  = numpy.zeros(self.profileShape, dtype=numpy.complex)
                 def run(self, dataOut, step, nsamples):
-                    dataOut.flagNoData = True
+                    dataOut.flagNoData      = True
-                    dataOut.flagDataAsBlock =False
+                    dataOut.flagDataAsBlock = False
-                    profileIndex = None
+                    profileIndex            = None
                     if not self.isConfig:
                         self.setup(dataOut, step=step , nsamples=nsamples)
                     for j in range(self.buffer.shape[0]):
                         self.sshProfiles[j] = numpy.transpose(self.buffer[j])
-                    profileIndex =  self.nsamples
+                    profileIndex  =  self.nsamples
-                    deltaHeight  =  dataOut.heightList[1] - dataOut.heightList[0]
+                    deltaHeight   =  dataOut.heightList[1] - dataOut.heightList[0]
-                    ippSeconds   =  (deltaHeight*1.0e-6)/(0.15)
+                    ippSeconds    =  (deltaHeight*1.0e-6)/(0.15)
-                    #print "hi",dataOut.ippSeconds
-                    #print ippSeconds
                     dataOut.data            = self.sshProfiles
                     dataOut.flagNoData      = False
                     dataOut.heightList      = numpy.arange(self.buffer.shape[1]) *self.step*deltaHeight + dataOut.heightList[0]
                     dataOut.flagDataAsBlock = True
                     dataOut.ippSeconds      = ippSeconds
                     dataOut.step            = self.step
-                    #print dataOut.ippSeconds
             # import collections

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