schain Commit - r1675:d3470f93cd6c · Jicamarca Repository

update readNextUnit y minHei case equal 0

Alexander Valdez -

r1675:d3470f93cd6c

parent child

Context file:

r1675:d3470f93cd6c

Collapse all files

schainpy/controller.py +2 -2

                     if name == None:
                         if 'Reader' in datatype:
                             name = datatype
-                            datatype = name.replace('Reader','')
+                            datatype = name.replace('Reader', '')
                         else:
                             name = '{}Reader'.format(datatype)
                     if datatype == None:
                         if 'Reader' in name:
-                            datatype = name.replace('Reader','')
+                            datatype = name.replace('Reader', '')
                         else:
                             datatype = name
                             name = '{}Reader'.format(name)

schainpy/model/proc/jroproc_spectra.py +23 -17

                     self.dataOut.beam.codeList = self.dataIn.beam.codeList
                     self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
                     self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
+                    self.dataOut.runNextUnit = self.dataIn.runNextUnit
+                    try:
+                        self.dataOut.step = self.dataIn.step
+                    except:
+                        pass
                 def __getFft(self):
                     """
                     self.dataOut.blockSize = blocksize
                     self.dataOut.flagShiftFFT = False
-                def run(self, nProfiles=None, nFFTPoints=None, pairsList=None, ippFactor=None, shift_fft=False):
+                def run(self, nProfiles=None, nFFTPoints=None, pairsList=None, ippFactor=None, shift_fft=False, runNextUnit = 0):
+                    self.dataIn.runNextUnit = runNextUnit
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
                         if shift_fft:
                     self.dataOut.pairsList = pairs
                     return
-                def selectFFTs(self, minFFT, maxFFT):
+                def selectFFTs(self, minFFT, maxFFT ):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de puntos FFTs segun el rango
                     minFFT<= FFT <= maxFFT
                     """
                     if (minFFT > maxFFT):
                         raise ValueError("Error selecting heights: Height range (%d,%d) is not valid" % (minFFT, maxFFT))
                     self.selectFFTsByIndex(minIndex, maxIndex)
                     return 1
                 def getBeaconSignal(self, tauindex=0, channelindex=0, hei_ref=None):
                     newheis = numpy.where(
                         self.dataOut.heightList > self.dataOut.radarControllerHeaderObj.Taus[tauindex])
                 def selectFFTsByIndex(self, minIndex, maxIndex):
                     """
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_cspc = data_cspc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.ippSeconds = self.dataOut.ippSeconds*(self.dataOut.nFFTPoints / numpy.shape(data_cspc)[1])
                     self.dataOut.nFFTPoints = numpy.shape(data_cspc)[1]
                     self.dataOut.profilesPerBlock = numpy.shape(data_cspc)[1]
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0, :]
                         for ich in range(num_chan):
                             yy = jspectra[ich, ind_vel, :]
                             jspectra[ich, freq_dc, :] = numpy.dot(xx_aux, yy)
             class removeInterference(Operation):
                 def removeInterference2(self):
                     cspc = self.dataOut.data_cspc
                     spc = self.dataOut.data_spc
                     Heights = numpy.arange(cspc.shape[2])
                     realCspc = numpy.abs(cspc)
                     for i in range(cspc.shape[0]):
                         LinePower= numpy.sum(realCspc[i], axis=0)
                         Threshold = numpy.amax(LinePower)-numpy.sort(LinePower)[len(Heights)-int(len(Heights)*0.1)]
                     if n is not None:
                         self.n = int(n)
                     else:
                         self.__integrationtime = int(timeInterval)
                         self.n = None
                         self.__byTime = True
                         dataOut.data_spc = avgdata_spc
                         dataOut.data_cspc = avgdata_cspc
                         dataOut.data_dc = avgdata_dc
                         dataOut.nIncohInt *= self.n
                         dataOut.utctime = avgdatatime
                         dataOut.flagNoData = False
                     return dataOut
             class dopplerFlip(Operation):
                 def run(self, dataOut):
                     # arreglo 1: (num_chan, num_profiles, num_heights)
                     self.dataOut = dataOut
                     # JULIA-oblicua, indice 2
                     # arreglo 2: (num_profiles, num_heights)
                     jspectra = self.dataOut.data_spc[2]

schainpy/model/proc/jroproc_voltage.py +14 -10

             from schainpy.model.data.jrodata import Voltage,hildebrand_sekhon
             from schainpy.utils import log
             from time import time
+            # voltage proc master
             class VoltageProc(ProcessingUnit):
                     self.flip = 1
                     self.setupReq = False
-                def run(self):
+                def run(self, runNextUnit = 0):
                     if self.dataIn.type == 'AMISR':
                         self.__updateObjFromAmisrInput()
                     if self.dataIn.type == 'Voltage':
                         self.dataOut.copy(self.dataIn)
+                        self.dataOut.runNextUnit = runNextUnit
                 def __updateObjFromAmisrInput(self):
                     self.dataOut = dataOut
-                    if minHei and maxHei:
+                    if type(minHei) == int or type(minHei) == float:
+                        v_minHei= True
+                    else:
+                        v_minHei= False
+                    if v_minHei and maxHei:
                         if (minHei < self.dataOut.heightList[0]):
                             minHei = self.dataOut.heightList[0]
                         minIndex = 0
                         maxIndex = 0
                         heights = self.dataOut.heightList
                         inda = numpy.where(heights >= minHei)
                         indb = numpy.where(heights <= maxHei)
                             maxIndex = indb[0][-1]
                         except:
                             maxIndex = len(heights)
+                    print(minIndex)
+                    print(maxIndex)
                     self.selectHeightsByIndex(minIndex, maxIndex)
                     return self.dataOut
                     """
                     if self.dataOut.type == 'Voltage':
+                        print(minIndex)
+                        print(maxIndex)
                         if (minIndex < 0) or (minIndex > maxIndex):
                             raise ValueError("Height index range (%d,%d) is not valid" % (minIndex, maxIndex))
                     if not self.isConfig:
                         self.setup(n=n, stride=stride, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
                         self.isConfig = True
                     if dataOut.flagDataAsBlock:
                         """
                         Si la data es leida por bloques, dimension = [nChannels, nProfiles, nHeis]
                     dataOut.nBaud = self.nBaud
                     dataOut.data = datadec
                     dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
                     dataOut.flagDecodeData = True #asumo q la data esta decodificada
                     self.__profIndex += 1
                     return dataOut
-                #        dataOut.flagDeflipData = True #asumo q la data no esta sin flip
             class ProfileConcat(Operation):
             #
             #         self.__startIndex += self.__newNSamples
             #
-            #         return
+            #         return
  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