schain Commit - r1338:317db0cd9a09 · Jicamarca Repository

Add metadata attribute to data types

jespinoza -

r1338:317db0cd9a09

parent child

Context file:

r1338:317db0cd9a09

schainpy/model/data/jroamisr.py +5 -8

                     for key in list(inputObj.__dict__.keys()):
                         self.__dict__[key] = inputObj.__dict__[key]
-                def getNHeights(self):
+                @property
+                def nHeights(self):
                     return len(self.heightList)
                     return self.flagNoData
-                def getTimeInterval(self):
+                @property
+                def timeInterval(self):
-                    timeInterval = self.ippSeconds * self.nCohInt
+                    return self.ippSeconds * self.nCohInt
-                    return timeInterval
-                timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
-                nHeights = property(getNHeights, "I'm the 'nHeights' property.")
  No newline at end of file

schainpy/model/data/jrodata.py +92 -299

-            '''
+            # Copyright (c) 2012-2020 Jicamarca Radio Observatory
+            # All rights reserved.
+            #
+            # Distributed under the terms of the BSD 3-clause license.
+            """Definition of diferent Data objects for different types of data
-            $Author: murco $
+            Here you will find the diferent data objects for the different types
-            $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
+            of data, this data objects must be used as dataIn or dataOut objects in
-            '''
+            processing units and operations. Currently the supported data objects are:
+            Voltage, Spectra, SpectraHeis, Fits, Correlation and Parameters
+            """
             import copy
             import numpy
             class JROData(GenericData):
-                #    m_BasicHeader = BasicHeader()
-                #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
-            #    data = None
                 type = None
                 datatype = None  # dtype but in string
-            #     dtype = None
-            #    nChannels = None
-            #    nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
-            #     nCode = None
-            #     nBaud = None
-            #     code = None
                 flagDecodeData = False  # asumo q la data no esta decodificada
                 flagDeflipData = False  # asumo q la data no esta sin flip
                 flagShiftFFT = False
-            #     ippSeconds = None
-            #     timeInterval = None
                 nCohInt = None
-            #     noise = None
                 windowOfFilter = 1
-                # Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 error = None
                 data = None
                 nmodes = None
+                metadata_list = ['heightList', 'timeZone', 'type']
                 def __str__(self):
-                    return '{} - {}'.format(self.type, self.getDatatime())
+                    return '{} - {}'.format(self.type, self.datatime())
                 def getNoise(self):
                     raise NotImplementedError
-                def getNChannels(self):
+                @property
+                def nChannels(self):
                     return len(self.channelList)
-                def getChannelIndexList(self):
+                @property
+                def channelIndexList(self):
                     return list(range(self.nChannels))
-                def getNHeights(self):
+                @property
+                def nHeights(self):
                     return len(self.heightList)
-                def getHeiRange(self, extrapoints=0):
-                    heis = self.heightList
-            #        deltah = self.heightList[1] - self.heightList[0]
-            #        heis.append(self.heightList[-1])
-                    return heis
                 def getDeltaH(self):
-                    delta = self.heightList[1] - self.heightList[0]
+                    return self.heightList[1] - self.heightList[0]
-                    return delta
+                @property
+                def ltctime(self):
-                def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone * 60
                     return self.utctime
-                def getDatatime(self):
+                @property
+                def datatime(self):
                     datatimeValue = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatimeValue
                     return vmax
-                def get_ippSeconds(self):
+                @property
+                def ippSeconds(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ippSeconds
-                def set_ippSeconds(self, ippSeconds):
+                @ippSeconds.setter
+                def ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.radarControllerHeaderObj.ippSeconds = ippSeconds
-                    return
+                @property
+                def code(self):
-                def get_dtype(self):
                     '''
                     '''
-                    return getNumpyDtype(self.datatype)
+                    return self.radarControllerHeaderObj.code
-                def set_dtype(self, numpyDtype):
+                @code.setter
+                def code(self, code):
                     '''
                     '''
+                    self.radarControllerHeaderObj.code = code
-                    self.datatype = getDataTypeCode(numpyDtype)
+                @property
+                def ncode(self):
-                def get_code(self):
                     '''
                     '''
-                    return self.radarControllerHeaderObj.code
+                    return self.radarControllerHeaderObj.nCode
-                def set_code(self, code):
+                @ncode.setter
+                def ncode(self, ncode):
                     '''
                     '''
-                    self.radarControllerHeaderObj.code = code
+                    self.radarControllerHeaderObj.nCode = ncode
-                    return
+                @property
+                def nbaud(self):
-                def get_ncode(self):
                     '''
                     '''
-                    return self.radarControllerHeaderObj.nCode
+                    return self.radarControllerHeaderObj.nBaud
-                def set_ncode(self, nCode):
+                @nbaud.setter
+                def nbaud(self, nbaud):
                     '''
                     '''
-                    self.radarControllerHeaderObj.nCode = nCode
+                    self.radarControllerHeaderObj.nBaud = nbaud
-                    return
+                @property
+                def ipp(self):
-                def get_nbaud(self):
                     '''
                     '''
-                    return self.radarControllerHeaderObj.nBaud
+                    return self.radarControllerHeaderObj.ipp
-                def set_nbaud(self, nBaud):
+                @ipp.setter
+                def ipp(self, ipp):
                     '''
                     '''
-                    self.radarControllerHeaderObj.nBaud = nBaud
+                    self.radarControllerHeaderObj.ipp = ipp
-                    return
+                @property
+                def metadata(self):
+                    '''
+                    '''
-                nChannels = property(getNChannels, "I'm the 'nChannel' property.")
+                    return {attr: getattr(self, attr) for attr in self.metadata_list}
-                channelIndexList = property(
-                    getChannelIndexList, "I'm the 'channelIndexList' property.")
-                nHeights = property(getNHeights, "I'm the 'nHeights' property.")
-                #noise = property(getNoise, "I'm the 'nHeights' property.")
-                datatime = property(getDatatime, "I'm the 'datatime' property")
-                ltctime = property(getltctime, "I'm the 'ltctime' property")
-                ippSeconds = property(get_ippSeconds, set_ippSeconds)
-                dtype = property(get_dtype, set_dtype)
-            #     timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
-                code = property(get_code, set_code)
-                nCode = property(get_ncode, set_ncode)
-                nBaud = property(get_nbaud, set_nbaud)
             class Voltage(JROData):
-                # data es un numpy array de 2 dmensiones (canales, alturas)
-                data = None
                 dataPP_POW   = None
                 dataPP_DOP   = None
                 dataPP_WIDTH = None
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
-            #         self.dtype = None
-            #        self.nChannels = 0
-            #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
-            #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.flagShiftFFT = False
                     self.flagDataAsBlock = False  # Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
+                    self.metadata_list = ['type', 'heightList', 'timeZone', 'nProfiles', 'channelList', 'nCohInt',
+                        'code', 'ncode', 'nbaud', 'ippSeconds', 'ipp']
                 def getNoisebyHildebrand(self, channel=None):
                     """
                     return powerdB
-                def getTimeInterval(self):
+                @property
+                def timeInterval(self):
-                    timeInterval = self.ippSeconds * self.nCohInt
-                    return timeInterval
+                    return self.ippSeconds * self.nCohInt
                 noise = property(getNoise, "I'm the 'nHeights' property.")
-                timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Spectra(JROData):
-                # data spc es un numpy array de 2 dmensiones (canales, perfiles, alturas)
-                data_spc = None
-                # data cspc es un numpy array de 2 dmensiones (canales, pares, alturas)
-                data_cspc = None
-                # data dc es un numpy array de 2 dmensiones (canales, alturas)
-                data_dc = None
-                # data power
-                data_pwr = None
-                nFFTPoints = None
-            #     nPairs = None
-                pairsList = None
-                nIncohInt = None
-                wavelength = None  # Necesario para cacular el rango de velocidad desde la frecuencia
-                nCohInt = None  # se requiere para determinar el valor de timeInterval
-                ippFactor = None
-                profileIndex = 0
-                plotting = "spectra"
                 def __init__(self):
                     '''
                     Constructor
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
                     self.timeZone = 0
-            #        self.data = None
-            #         self.dtype = None
-            #        self.nChannels = 0
-            #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
-            #        self.channelIndexList = None
                     self.pairsList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.ippFactor = 1
-                    #self.noise = None
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
+                    self.metadata_list = ['type', 'heightList', 'timeZone', 'pairsList', 'channelList', 'nCohInt',
+                        'code', 'ncode', 'nbaud', 'ippSeconds', 'ipp','nIncohInt', 'nFFTPoints', 'nProfiles']
                 def getNoisebyHildebrand(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     """
                     else:
                         return velrange
-                def getNPairs(self):
+                @property
+                def nPairs(self):
                     return len(self.pairsList)
-                def getPairsIndexList(self):
+                @property
+                def pairsIndexList(self):
                     return list(range(self.nPairs))
-                def getNormFactor(self):
+                @property
+                def normFactor(self):
                     pwcode = 1
                     return normFactor
-                def getFlagCspc(self):
+                @property
+                def flag_cspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
-                def getFlagDc(self):
+                @property
+                def flag_dc(self):
                     if self.data_dc is None:
                         return True
                     return False
-                def getTimeInterval(self):
+                @property
+                def timeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles * self.ippFactor
                     if self.nmodes:
                     return
-                nPairs = property(getNPairs, setValue, "I'm the 'nPairs' property.")
-                pairsIndexList = property(
-                    getPairsIndexList, setValue, "I'm the 'pairsIndexList' property.")
-                normFactor = property(getNormFactor, setValue,
-                                      "I'm the 'getNormFactor' property.")
-                flag_cspc = property(getFlagCspc, setValue)
-                flag_dc = property(getFlagDc, setValue)
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
-                timeInterval = property(getTimeInterval, setValue,
-                                        "I'm the 'timeInterval' property")
             class SpectraHeis(Spectra):
-                data_spc = None
-                data_cspc = None
-                data_dc = None
-                nFFTPoints = None
-            #     nPairs = None
-                pairsList = None
-                nCohInt = None
-                nIncohInt = None
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
-            #         self.dtype = None
-            #        self.nChannels = 0
-            #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
-            #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
-            #         self.nPairs = 0
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
-                def getNormFactor(self):
+                @property
+                def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     return normFactor
-                def getTimeInterval(self):
+                @property
+                def timeInterval(self):
-                    timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
-                    return timeInterval
-                normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
+                    return self.ippSeconds * self.nCohInt * self.nIncohInt
-                timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Fits(JROData):
-                heightList = None
-                channelList = None
-                flagNoData = True
-                flagDiscontinuousBlock = False
-                useLocalTime = False
-                utctime = None
-            #     ippSeconds = None
-            #     timeInterval = None
-                nCohInt = None
-                nIncohInt = None
-                noise = None
-                windowOfFilter = 1
-                # Speed of ligth
-                C = 3e8
-                frequency = 49.92e6
-                realtime = False
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
-            #         self.channelIndexList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
-            #         self.utctime = None
                     self.timeZone = 0
-            #         self.ltctime = None
-            #         self.timeInterval = None
-            #         self.header = None
-            #         self.data_header = None
-            #         self.data = None
-            #         self.datatime = None
-            #         self.flagNoData = False
-            #         self.expName = ''
-            #         self.nChannels = None
-            #         self.nSamples = None
-            #         self.dataBlocksPerFile = None
-            #         self.comments = ''
-                def getltctime(self):
-                    if self.useLocalTime:
-                        return self.utctime - self.timeZone * 60
-                    return self.utctime
-                def getDatatime(self):
-                    datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
-                    return datatime
                 def getTimeRange(self):
                     return datatime
-                def getHeiRange(self):
-                    heis = self.heightList
-                    return heis
-                def getNHeights(self):
-                    return len(self.heightList)
-                def getNChannels(self):
-                    return len(self.channelList)
                 def getChannelIndexList(self):
                     return list(range(self.nChannels))
                 def getNoise(self, type=1):
-                    #noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     return noise
-                def getTimeInterval(self):
+                @property
+                def timeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
-                def get_ippSeconds(self):
+                @property
+                def ippSeconds(self):
                     '''
                     '''
                     return self.ipp_sec
-                datatime = property(getDatatime, "I'm the 'datatime' property")
-                nHeights = property(getNHeights, "I'm the 'nHeights' property.")
-                nChannels = property(getNChannels, "I'm the 'nChannel' property.")
-                channelIndexList = property(
-                    getChannelIndexList, "I'm the 'channelIndexList' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
-                ltctime = property(getltctime, "I'm the 'ltctime' property")
-                timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
-                ippSeconds = property(get_ippSeconds, '')
             class Correlation(JROData):
-                noise = None
-                SNR = None
-                #--------------------------------------------------
-                mode = None
-                split = False
-                data_cf = None
-                lags = None
-                lagRange = None
-                pairsList = None
-                normFactor = None
-                #--------------------------------------------------
-            #     calculateVelocity = None
-                nLags = None
-                nPairs = None
-                nAvg = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Correlation"
                     self.data = None
                     self.dtype = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = 0
                     self.dstFlag = None
                     self.errorCount = None
                     self.blocksize = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.pairsList = None
                     self.nPoints = None
                 def getPairsList(self):
                     return noise
-                def getTimeInterval(self):
+                @property
+                def timeInterval(self):
-                    timeInterval = self.ippSeconds * self.nCohInt * self.nProfiles
+                    return self.ippSeconds * self.nCohInt * self.nProfiles
-                    return timeInterval
                 def splitFunctions(self):
                     return acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf
-                def getNormFactor(self):
+                @property
+                def normFactor(self):
                     acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.splitFunctions()
                     acf_pairs = numpy.array(acf_pairs)
                     normFactor = numpy.zeros((self.nPairs, self.nHeights))
                     return normFactor
-                timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
-                normFactor = property(getNormFactor, "I'm the 'normFactor property'")
             class Parameters(Spectra):
-                experimentInfo = None  # Information about the experiment
-                # Information from previous data
-                inputUnit = None  # Type of data to be processed
-                operation = None  # Type of operation to parametrize
-                # normFactor = None       #Normalization Factor
                 groupList = None  # List of Pairs, Groups, etc
-                # Parameters
                 data_param = None  # Parameters obtained
                 data_pre = None  # Data Pre Parametrization
                 data_SNR = None  # Signal to Noise Ratio
-            #     heightRange = None      #Heights
                 abscissaList = None  # Abscissa, can be velocities, lags or time
-            #    noise = None            #Noise Potency
                 utctimeInit = None  # Initial UTC time
                 paramInterval = None  # Time interval to calculate Parameters in seconds
                 useLocalTime = True
                     return datatime
-                def getTimeInterval(self):
+                @property
+                def timeInterval(self):
                     if hasattr(self, 'timeInterval1'):
                         return self.timeInterval1
                     return self.spc_noise
-                timeInterval = property(getTimeInterval)
                 noise = property(getNoise, setValue, "I'm the 'Noise' property.")
                     if hasattr(dataOut, 'pairsList'):
                         self.pairs = dataOut.pairsList
-                    self.interval = dataOut.getTimeInterval()
+                    self.interval = dataOut.timeInterval
                     if True in ['spc' in ptype for ptype in self.plottypes]:
                         self.xrange = (dataOut.getFreqRange(1)/1000.,
                                        dataOut.getAcfRange(1), dataOut.getVelRange(1))

schainpy/model/io/jroIO_base.py 0 -2

                     self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
-             #         self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
                 def getFirstHeader(self):
                     raise NotImplementedError

schainpy/model/io/jroIO_digitalRF.py +1 -1

                     self.dataOut.channelList = list(range(self.__num_subchannels))
-                    self.dataOut.blocksize   = self.dataOut.getNChannels() * self.dataOut.getNHeights()
+                    self.dataOut.blocksize   = self.dataOut.nChannels * self.dataOut.nHeights
                     # self.dataOut.channelIndexList = None

schainpy/model/io/jroIO_hf.py +1 -1

                     self.dataOut.nCohInt = 1
-                    self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights()
+                    self.dataOut.blocksize = self.dataOut.nChannels * self.dataOut.nHeights
                     self.dataOut.flagDecodeData = False #asumo que la data esta decodificada

schainpy/model/io/jroIO_kamisr.py +1 -1

                     self.dataOut.channelList = self.__channelList
-                    self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights()
+                    self.dataOut.blocksize = self.dataOut.nChannels * self.dataOut.nHeights
             #        self.dataOut.channelIndexList = None

schainpy/model/io/jroIO_mira35c.py +1 -1

                     self.dataOut.utctime = dwell
                     self.dataOut.timeZone = 0
-                    self.dataOut.outputInterval = self.dataOut.getTimeInterval()
+                    self.dataOut.outputInterval = self.dataOut.timeInterval
                     self.dataOut.heightList = self.SPARrawGate1 * self.__deltaHeigth + \
                         numpy.array(list(range(self.Num_Hei))) * self.__deltaHeigth

schainpy/model/io/jroIO_simulator.py +8 -8

                     self.datablock = numpy.zeros([channels,prof_gen,Samples],dtype= numpy.complex64)
                     for i in range(channels):
                         for k in range(prof_gen):
-                            #·······················NOISE···············
+                            #-----------------------NOISE---------------
                             Noise_r    = numpy.random.normal(DC_level,stdev,Samples)
                             Noise_i    = numpy.random.normal(DC_level,stdev,Samples)
                             Noise      = numpy.zeros(Samples,dtype=complex)
                             Noise.real = Noise_r
                             Noise.imag = Noise_i
-                            #·······················PULSOS··············
+                            #-----------------------PULSOS--------------
                             Pulso      = numpy.zeros(pulse_size,dtype=complex)
                             Pulso.real =  pulses[k%num_codes]
                             Pulso.imag =  pulses[k%num_codes]
-                            #····················· PULSES+NOISE··········
+                            #--------------------- PULSES+NOISE----------
                             InBuffer                    = numpy.zeros(Samples,dtype=complex)
                             InBuffer[m_nR:m_nR+ps]      = Pulso
                             InBuffer                    =  InBuffer+Noise
-                            #····················· ANGLE ·······························
+                            #--------------------- ANGLE -------------------------------
                             InBuffer.real[m_nR:m_nR+ps] = InBuffer.real[m_nR:m_nR+ps]*(math.cos( self.fAngle)*5)
                             InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps]*(math.sin( self.fAngle)*5)
                             InBuffer=InBuffer
                             self.datablock[i][k]= InBuffer
-                    #················DOPPLER SIGNAL...............................................
+                    #----------------DOPPLER SIGNAL...............................................
                     time_vec   = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen+(self.nReadFiles-1)*ippSec*prof_gen
                     fd         = Fdoppler #+(600.0/120)*self.nReadBlocks
                     d_signal   = Adoppler*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
-                    #·············Señal con ancho espectral····················
+                    #-------------Senal con ancho espectral--------------------
                     if prof_gen%2==0:
                         min = int(prof_gen/2.0-1.0)
                         max = int(prof_gen/2.0)
                     specw_sig   = specw_sig/w
                     specw_sig   = numpy.sinc(specw_sig)
                     specw_sig   =  A*numpy.array(specw_sig,dtype=numpy.complex64)
-                    #·················· DATABLOCK + DOPPLER····················
+                    #------------------ DATABLOCK + DOPPLER--------------------
                     HD=int(Hdoppler/self.AcqDH_0)
                     for  i in range(12):
                         self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ d_signal# RESULT
-                    #·················· DATABLOCK + DOPPLER*Sinc(x)····················
+                    #------------------ DATABLOCK + DOPPLER*Sinc(x)--------------------
                     HD=int(Hdoppler/self.AcqDH_0)
                     HD=int(HD/2)
                     for  i in range(12):

schainpy/model/io/jroIO_usrp.py +1 -1

                     self.dataOut.channelList = self.__channelList
-                    self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights()
+                    self.dataOut.blocksize = self.dataOut.nChannels * self.dataOut.nHeights
             #        self.dataOut.channelIndexList = None

schainpy/model/proc/jroproc_heispectra.py 0 -3

                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
-                            print(channelIndexList)
                             raise ValueError("The value %d in channelIndexList is not valid" %channelIndex)
-            #         nChannels = len(channelIndexList)
                     data_spc = self.dataOut.data_spc[channelIndexList,:]
                     self.dataOut.data_spc = data_spc

schainpy/model/proc/jroproc_parameters.py +7 -7

                     self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
             #         self.dataOut.nHeights = self.dataIn.nHeights
             #         self.dataOut.nChannels = self.dataIn.nChannels
-                    self.dataOut.nBaud = self.dataIn.nBaud
+                    # self.dataOut.nBaud = self.dataIn.nBaud
-                    self.dataOut.nCode = self.dataIn.nCode
+                    # self.dataOut.nCode = self.dataIn.nCode
-                    self.dataOut.code = self.dataIn.code
+                    # self.dataOut.code = self.dataIn.code
             #        self.dataOut.nProfiles = self.dataOut.nFFTPoints
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
             #         self.dataOut.utctime = self.firstdatatime
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
                     self.dataOut.nCohInt = self.dataIn.nCohInt
             #        self.dataOut.nIncohInt = 1
-                    self.dataOut.ippSeconds = self.dataIn.ippSeconds
+            #        self.dataOut.ippSeconds = self.dataIn.ippSeconds
             #        self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
                     self.dataOut.timeInterval1 = self.dataIn.timeInterval
-                    self.dataOut.heightList = self.dataIn.getHeiRange()
+                    self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.frequency = self.dataIn.frequency
                     # self.dataOut.noise = self.dataIn.noise
                         channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)]   #Estrella
                     meteorOps = SMOperations()
                     pairslist0, distances = meteorOps.getPhasePairs(channelPositions)
-                    heiRang = dataOut.getHeiRange()
+                    heiRang = dataOut.heightList
                     #Get Beacon signal - No Beacon signal anymore
             #         newheis = numpy.where(self.dataOut.heightList>self.dataOut.radarControllerHeaderObj.Taus[tauindex])
             #
                     #************** REMOVE MULTIPLE DETECTIONS (3.5) ***************************
                     #Parameters
-                    heiRange = dataOut.getHeiRange()
+                    heiRange = dataOut.heightList
                     rangeInterval = heiRange[1] - heiRange[0]
                     rangeLimit = multDet_rangeLimit/rangeInterval
                     timeLimit = multDet_timeLimit/dataOut.timeInterval

schainpy/model/proc/jroproc_spectra.py +18 -26

+            # Copyright (c) 2012-2020 Jicamarca Radio Observatory
+            # All rights reserved.
+            #
+            # Distributed under the terms of the BSD 3-clause license.
+            """Spectra processing Unit and operations
+            Here you will find the processing unit `SpectraProc` and several operations
+            to work with Spectra data type
+            """
             import time
             import itertools
             class SpectraProc(ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     except:
                         pass
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
-                    self.dataOut.nBaud = self.dataIn.nBaud
-                    self.dataOut.nCode = self.dataIn.nCode
-                    self.dataOut.code = self.dataIn.code
                     self.dataOut.nProfiles = self.dataOut.nFFTPoints
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
                     self.dataOut.utctime = self.firstdatatime
-                    # asumo q la data esta decodificada
                     self.dataOut.flagDecodeData = self.dataIn.flagDecodeData
-                    # asumo q la data esta sin flip
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData
                     self.dataOut.flagShiftFFT = False
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = 1
                     self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
                     self.dataOut.frequency = self.dataIn.frequency
                     self.dataOut.realtime = self.dataIn.realtime
                     self.dataOut.azimuth = self.dataIn.azimuth
                     self.dataOut.zenith = self.dataIn.zenith
                     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.blockSize = blocksize
                     self.dataOut.flagShiftFFT = False
-                def run(self, nProfiles=None, nFFTPoints=None, pairsList=[], ippFactor=None, shift_fft=False):
+                def run(self, nProfiles=None, nFFTPoints=None, pairsList=None, ippFactor=None, shift_fft=False):
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
                                 #desplaza a la derecha en el eje 2 determinadas posiciones
                                 self.dataOut.data_cspc = numpy.roll(self.dataOut.data_cspc, shift, axis=1)
-                        return True
+                    elif self.dataIn.type == "Voltage":
-                    if self.dataIn.type == "Voltage":
                         self.dataOut.flagNoData = True
                             nProfiles = nFFTPoints
                         if ippFactor == None:
-                            ippFactor = 1
+                            self.dataOut.ippFactor = 1
-                        self.dataOut.ippFactor = ippFactor
                         self.dataOut.nFFTPoints = nFFTPoints
-                        self.dataOut.pairsList = pairsList
                         if self.buffer is None:
                             self.buffer = numpy.zeros((self.dataIn.nChannels,
                                 raise ValueError("The type object %s has %d profiles, it should just has %d profiles" % (
                                     self.dataIn.type, self.dataIn.data.shape[1], nProfiles))
                                 self.dataOut.flagNoData = True
-                                return 0
                         else:
                             self.buffer[:, self.profIndex, :] = self.dataIn.data.copy()
                             self.profIndex += 1
                         if self.profIndex == nProfiles:
                             self.__updateSpecFromVoltage()
+                            if pairsList == None:
+                                self.dataOut.pairsList = [pair for pair in itertools.combinations(self.dataOut.channelList, 2)]
                             self.__getFft()
                             self.dataOut.flagNoData = False
                             self.firstdatatime = None
                             self.profIndex = 0
+                    else:
-                        return True
+                        raise ValueError("The type of input object '%s' is not valid".format(
-                    raise ValueError("The type of input object '%s' is not valid" % (
                             self.dataIn.type))
                 def __selectPairs(self, pairsList):

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

                 def run(self, dataOut, attributes):
+                    if isinstance(attributes, str):
+                        attributes = [attributes]
                     for attr in attributes:
                         if hasattr(dataOut, attr):
                             log.log(getattr(dataOut, attr), attr)
                     Return the PULSEPAIR and the profiles used in the operation
                     Affected :  self.__profileIndex
                     '''
-                    #················· Remove DC···································
+                    #----------------- Remove DC-----------------------------------
                     if self.removeDC==True:
                         mean    = numpy.mean(self.__buffer,1)
                         tmp     = mean.reshape(self.__nch,1,self.__nHeis)
                         dc= numpy.tile(tmp,[1,self.__nProf,1])
                         self.__buffer = self.__buffer -  dc
-                    #··················Calculo de Potencia ························
+                    #------------------Calculo de Potencia ------------------------
                     pair0       = self.__buffer*numpy.conj(self.__buffer)
                     pair0       = pair0.real
                     lag_0       = numpy.sum(pair0,1)
-                    #··················Calculo de Ruido x canal····················
+                    #------------------Calculo de Ruido x canal--------------------
                     self.noise  = numpy.zeros(self.__nch)
                     for i in range(self.__nch):
                         daux         = numpy.sort(pair0[i,:,:],axis= None)
                     self.noise       = numpy.tile(self.noise,[1,self.__nHeis])
                     noise_buffer     = self.noise.reshape(self.__nch,1,self.__nHeis)
                     noise_buffer     = numpy.tile(noise_buffer,[1,self.__nProf,1])
-                    #·················· Potencia recibida= P , Potencia senal = S , Ruido= N··
+                    #------------------ Potencia recibida= P , Potencia senal = S , Ruido= N--
-                    #··················   P= S+N  ,P=lag_0/N ·································
+                    #------------------   P= S+N  ,P=lag_0/N ---------------------------------
-                    #···················· Power ··················································
+                    #-------------------- Power --------------------------------------------------
                     data_power       = lag_0/(self.n*self.nCohInt)
-                    #------------------  Senal  ···················································
+                    #------------------  Senal  ---------------------------------------------------
                     data_intensity   = pair0 - noise_buffer
                     data_intensity   = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
                     #data_intensity   = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
                             if data_intensity[i][j]  < 0:
                                 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
-                    #················· Calculo de Frecuencia y Velocidad doppler········
+                    #----------------- Calculo de Frecuencia y Velocidad doppler--------
                     pair1            = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
                     lag_1            = numpy.sum(pair1,1)
                     data_freq        = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
                     data_velocity    = (self.lambda_/2.0)*data_freq
-                    #················ Potencia promedio estimada de la Senal···········
+                    #---------------- Potencia promedio estimada de la Senal-----------
                     lag_0            = lag_0/self.n
                     S                = lag_0-self.noise
-                    #················ Frecuencia Doppler promedio ·····················
+                    #---------------- Frecuencia Doppler promedio ---------------------
                     lag_1            = lag_1/(self.n-1)
                     R1               = numpy.abs(lag_1)
-                    #················ Calculo del SNR··································
+                    #---------------- Calculo del SNR----------------------------------
                     data_snrPP       = S/self.noise
                     for i in range(self.__nch):
                         for j in range(self.__nHeis):
                             if data_snrPP[i][j]  < 1.e-20:
                                 data_snrPP[i][j] = 1.e-20
-                    #················· Calculo del ancho espectral ······················
+                    #----------------- Calculo del ancho espectral ----------------------
                     L                = S/R1
                     L                = numpy.where(L<0,1,L)
                     L                = numpy.log(L)

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