schain Commit - r660:5880e83e7e4e · Jicamarca Repository

Bugs fixed:...

Miguel Valdez -

r660:5880e83e7e4e

parent child

Context file:

r660:5880e83e7e4e

Collapse all files

schainpy/model/proc/jroproc_voltage.py +49 -31

                         """
                         Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
                         """
-                        data = self.dataOut.data[:,minIndex:maxIndex,:]
+                        data = self.dataOut.data[:,:, minIndex:maxIndex]
                     else:
                         data = self.dataOut.data[:, minIndex:maxIndex]
                         print 'IOError: Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud)
                         raise IOError, 'Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud)
+                    #Frequency
+                    __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
+                    __codeBuffer[:,0:self.nBaud] = self.code
+                    self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
                     if dataOut.flagDataAsBlock:
                         self.ndatadec = self.__nHeis #- self.nBaud + 1
                     else:
-                        __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
+                        #Time
-                        __codeBuffer[:,0:self.nBaud] = self.code
-                        self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
                         self.ndatadec = self.__nHeis #- self.nBaud + 1
                         self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
-                def convolutionInFreq(self, data):
+                def __convolutionInFreq(self, data):
                     fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
                     data = numpy.fft.ifft(conv,axis=1)
-                    datadec = data#[:,:]
+                    return data
-                    return datadec
-                def convolutionInFreqOpt(self, data):
+                def __convolutionInFreqOpt(self, data):
                     raise NotImplementedError
             #
             #         return datadec
-                def convolutionInTime(self, data):
+                def __convolutionInTime(self, data):
                     code = self.code[self.__profIndex]
                     return self.datadecTime
-                def convolutionByBlockInTime(self, data):
+                def __convolutionByBlockInTime(self, data):
                     repetitions = self.__nProfiles / self.nCode
                     for i in range(self.__nChannels):
                         for j in range(self.__nProfiles):
-                            self.datadecTime[i,j,:] = numpy.correlate(data[i,j,:], code_block[j,:], mode='same')
+                            self.datadecTime[i,j,:] = numpy.correlate(data[i,j,:], code_block[j,:], mode='full')[self.nBaud-1:]
                     return self.datadecTime
+                def __convolutionByBlockInFreq(self, data):
+                    fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
+                    fft_data = numpy.fft.fft(data, axis=2)
+                    conv = fft_data*fft_code
+                    data = numpy.fft.ifft(conv,axis=2)
+                    return data
                 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0, osamp=None, times=None):
                     if dataOut.flagDecodeData:
                         print "Fail decoding: Code is not defined."
                         return
+                    datadec = None
                     if dataOut.flagDataAsBlock:
                         """
                         Decoding when data have been read as block,
                         """
-                        datadec = self.convolutionByBlockInTime(dataOut.data)
+                        if mode == 0:
+                            datadec = self.__convolutionByBlockInTime(dataOut.data)
+                        if mode == 1:
+                            datadec = self.__convolutionByBlockInFreq(dataOut.data)
                     else:
                         """
                         Decoding when data have been read profile by profile
                         """
                         if mode == 0:
-                            datadec = self.convolutionInTime(dataOut.data)
+                            datadec = self.__convolutionInTime(dataOut.data)
                         if mode == 1:
-                            datadec = self.convolutionInFreq(dataOut.data)
+                            datadec = self.__convolutionInFreq(dataOut.data)
                         if mode == 2:
-                            datadec = self.convolutionInFreqOpt(dataOut.data)
+                            datadec = self.__convolutionInFreqOpt(dataOut.data)
+                    if datadec is None:
+                        raise ValueError, "Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode
                     dataOut.code = self.code
                     dataOut.nCode = self.nCode
                     dataOut.data = datadec
-                    dataOut.heightList = dataOut.heightList[0:self.ndatadec]
+                    dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
                     dataOut.flagDecodeData = True #asumo q la data esta decodificada
                     dataOut.flagNoData = True
-                    if nProfiles:
-                        self.nProfiles = dataOut.nProfiles
-                    else:
-                        self.nProfiles = nProfiles
                     if dataOut.flagDataAsBlock:
                         """
                         data dimension  = [nChannels, nProfiles, nHeis]
                         return True
-                    else:
                     """
                     data dimension  = [nChannels, nHeis]
                     """
+                    if nProfiles:
+                        self.nProfiles = nProfiles
+                    else:
+                        self.nProfiles = dataOut.nProfiles
                     if profileList != None:
                         dataOut.nProfiles = len(profileList)
                             self.incIndex()
                         return True
                     if profileRangeList != None:
                         minIndex = profileRangeList[0]
                             dataOut.profileIndex = self.profileIndex
                             self.incIndex()
-                            return 1
+                        return True
                     raise ValueError, "ProfileSelector needs profileList, profileRangeList or rangeList parameter"
-                    return 0
+                    return False

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