schain Commit - r762:7c90b920ac51 · Jicamarca Repository

Correction to Spaced Antenna libraries

Julio Valdez -

r762:7c90b920ac51

parent child

Context file:

r762:7c90b920ac51

Collapse all files

schainpy/model/proc/jroproc_correlation.py +1 -1

                     self.dataOut.utctime = self.firstdatatime
                     self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
-            #        self.dataOut.nCohInt = self.dataIn.nCohInt
+                    self.dataOut.nCohInt = self.dataIn.nCohInt
             #        self.dataOut.nIncohInt = 1
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
             #        self.dataOut.windowOfFilter = self.dataIn.windowOfFilter

schainpy/model/proc/jroproc_parameters.py +36 -26

                     self.dataOut.heightList = self.dataIn.getHeiRange()
                     self.dataOut.frequency = self.dataIn.frequency
-                def run(self, nSeconds = None, nProfiles = None):
+                def run(self, nSeconds = 100, nProfiles = None):
                     if self.dataIn.type == "Voltage":
                         self.dataOut.flagNoData = True
-                        if nSeconds != None:
+                        if self.buffer == None:
                             self.nSeconds = nSeconds
                             self.nProfiles= int(numpy.floor(nSeconds/(self.dataIn.ippSeconds*self.dataIn.nCohInt)))
+                            self.buffer = numpy.zeros((self.dataIn.nChannels,
+                                                       self.nProfiles,
+                                                       self.dataIn.nHeights),
+                                                       dtype='complex')
-                        if self.buffer is None:
+                        if self.profIndex == 7990:
-                                self.buffer = numpy.zeros((self.dataIn.nChannels,
+                            a = 1
-                                                           self.nProfiles,
-                                                           self.dataIn.nHeights),
-                                                           dtype='complex')
                         self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
                         self.profIndex += 1
                     self.__updateObjFromInput()
                     self.firstdatatime = None
                     self.dataOut.utctimeInit = self.dataIn.utctime
-                    self.dataOut.outputInterval = self.dataIn.timeInterval
+                    self.dataOut.paramInterval = self.dataIn.timeInterval
                 #-------------------    Get Moments    ----------------------------------
                 def GetMoments(self, channelList = None):
                     elif (self.smooth < 3): smooth = 0
                     if (type1 == None): type1 = 0
-                    if (fwindow is None): fwindow = numpy.zeros(oldfreq.size) + 1
+                    if (fwindow == None): fwindow = numpy.zeros(oldfreq.size) + 1
                     if (snrth == None): snrth = -3
                     if (dc == None): dc = 0
                     if (aliasing == None): aliasing = 0
                     #***************************+     PASS DATA TO NEXT STEP    **********************
                         arrayFinal = arrayParameters.reshape((1,arrayParameters.shape[0],arrayParameters.shape[1]))
                         self.dataOut.data_param = arrayFinal
+                        if arrayFinal == None:
+                            self.dataOut.flagNoData = True
                     return
                 def __getHardwarePhaseDiff(self, voltage0, pairslist, newheis, n):
                     date = re.findall(r'\((.*?)\)', date)
                     date = date[0].split(',')
                     date = map(int, date)
+                    if len(date)<6:
+                        date.append(0)
                     date = [date[0]*10000 + date[1]*100 + date[2], date[3]*10000 + date[4]*100 + date[5]]
                     arrayDate = numpy.tile(date, (len(listMeteors), 1))
                                 error1 = p0*numpy.nan
                             #Save
-                            if self.dataOut.data_param is None:
+                            if self.dataOut.data_param == None:
                                 self.dataOut.data_param = numpy.zeros((nGroups, p0.size, nHeights))*numpy.nan
                                 self.dataOut.data_error = numpy.zeros((nGroups, p0.size + 1, nHeights))*numpy.nan
                     Parameters affected:    Winds
                     '''
-                    print arrayMeteor.shape
+            #         print arrayMeteor.shape
                     #Settings
                     nInt = (heightMax - heightMin)/2
+            #         print nInt
+                    nInt = int(nInt)
+            #         print nInt
                     winds = numpy.zeros((2,nInt))*numpy.nan
                     #Filter errors
                 def run(self, dataOut, technique, **kwargs):
                     param = dataOut.data_param
-            #         if dataOut.abscissaList != None:
+                    if dataOut.abscissaList != None:
-            #             absc = dataOut.abscissaList[:-1]
+                        absc = dataOut.abscissaList[:-1]
                     noise = dataOut.noise
                     heightList = dataOut.heightList
                     SNR = dataOut.data_SNR
                             self.__isConfig = True
-                        if self.__buffer is None:
+                        if self.__buffer == None:
                             self.__buffer = dataOut.data_param
                             self.__firstdata = copy.copy(dataOut)
                 def __getGammas(self, pairs, k, d, phases):
                     gammas = numpy.zeros(2)
                     for i in range(len(pairs)):
                         pairi = pairs[i]
                         phasesX = phaseHisto[1][:-1]
                         width = phasesX[1] - phasesX[0]
                         phasesX += width/2
                         #Gaussian aproximation
                         bpeak = meteorsY.argmax()
                         peak = meteorsY.max()
                         #Gammas
                         gammas[i] = coeff[0][1]
-            #             gammas[i] = bpeak
                     return gammas
                 def __residualFunction(self, coeffs, y, t):
                     pairy = pairsList[1]
                     center_xangle = 0
                     center_yangle = 0
-                    range_angle = numpy.array([8*numpy.pi,numpy.pi,numpy.pi/2,numpy.pi/4])
+                    range_angle = numpy.array([10*numpy.pi,numpy.pi,numpy.pi/2,numpy.pi/4])
                     ntimes = len(range_angle)
                     nstepsx = 20.0
                         self.__isConfig = True
-                    if self.__buffer is None:
+                    if self.__buffer == None:
                         self.__buffer = dataOut.data_param.copy()
                     else:
                     indInvalid1 = numpy.where(numpy.logical_and(h_bool == 0, error == 0))[0]
                     error[indInvalid1] = 13
-                    return heights, error
+                    return heights, error
  No newline at end of file
-  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