schain-jc Commit - r179:e4faab4afbdd

Cambio en los atributos: dataIn, dataOut.

Daniel Valdez -

r179:e4faab4afbdd

parent child

Context file:

r179:e4faab4afbdd

Collapse all files

schainpy/model/__init__.py created 644 +3 0

@@ -0,0 +1,3
	1	import jrodata
	2	import jrodataIO
	3	import jroprocessing

schainpy/model/jrodataIO.py +181 -181

                 c = 3E8
-                __isConfig = False
+                isConfig = False
                 basicHeaderObj = BasicHeader()
                 datablock = None
-                dataOutObj = None
+                dataOut = None
                 blocksize = None
                     return directory, filename, year, doy, set
-                def setup(self,dataOutObj=None,
+                def setup(self,dataOut=None,
                             path=None,
                             startDate=None,
                             endDate=None,
                     if ext == None:
                         ext = self.ext
-                    if dataOutObj == None:
+                    if dataOut == None:
-                        dataOutObj = self.createObjByDefault()
+                        dataOut = self.createObjByDefault()
-                    self.dataOutObj = dataOutObj
+                    self.dataOut = dataOut
                     if online:
                         print "Searching files in online mode..."
             #        self.updateDataHeader()
-                    return self.dataOutObj
+                    return self.dataOut
                 def __setNextFileOffline(self):
                     self.dtype = datatype_str
                     self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
-            #        self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
+            #        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
-            #        self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
+            #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def run(self, **kwargs):
-                    if not(self.__isConfig):
+                    if not(self.isConfig):
-                        self.dataOutObj = dataOut
+            #            self.dataOut = dataOut
                         self.setup(**kwargs)
-                        self.__isConfig = True
+                        self.isConfig = True
                     self.getData()
                 nWriteBlocks = 0
-                def __init__(self, dataOutObj=None):
+                def __init__(self, dataOut=None):
                     raise ValueError, "Not implemented"
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
-                    utc = numpy.floor(self.dataOutObj.utctime)
+                    utc = numpy.floor(self.dataOut.utctime)
-                    milisecond  = (self.dataOutObj.utctime - utc)* 1000.0
+                    milisecond  = (self.dataOut.utctime - utc)* 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond
                     self.radarControllerHeaderObj.write(self.fp)
                     self.processingHeaderObj.write(self.fp)
-                    self.dtype = self.dataOutObj.dtype
+                    self.dtype = self.dataOut.dtype
                 def __setNewBlock(self):
                     """
                     if self.fp != None:
                         self.fp.close()
-                    timeTuple = time.localtime( self.dataOutObj.dataUtcTime)
+                    timeTuple = time.localtime( self.dataOut.dataUtcTime)
                     subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     doypath = os.path.join( path, subfolder )
                 def run(self, dataOut, **kwargs):
-                    if not(self.__isConfig):
+                    if not(self.isConfig):
-                        self.dataOutObj = dataOut
+                        self.dataOut = dataOut
                         self.setup(**kwargs)
-                        self.__isConfig = True
+                        self.isConfig = True
                     self.putData()
                 ext = ".r"
                 optchar = "D"
-                dataOutObj = None
+                dataOut = None
-                def __init__(self, dataOutObj=None):
+                def __init__(self, dataOut=None):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
-                        dataOutObj    :    Objeto de la clase Voltage. Este objeto sera utilizado para
+                        dataOut    :    Objeto de la clase Voltage. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           Si este parametro no es pasado se creara uno internamente.
                     Variables afectadas:
-                        self.dataOutObj
+                        self.dataOut
                     Return:
                         None
                     """
-                    self.__isConfig = False
+                    self.isConfig = False
                     self.datablock = None
                                      buffer. Si no hay mas archivos a leer retorna None.
                     Variables afectadas:
-                        self.dataOutObj
+                        self.dataOut
                         self.profileIndex
                     Affected:
-                        self.dataOutObj
+                        self.dataOut
                         self.profileIndex
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.datablock == None:
-                        self.dataOutObj.flagNoData = True
+                        self.dataOut.flagNoData = True
                         return 0
-                    self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
+                    self.dataOut.data = self.datablock[:,self.profileIndex,:]
-                    self.dataOutObj.dtype = self.dtype
+                    self.dataOut.dtype = self.dtype
-                    self.dataOutObj.nChannels = self.systemHeaderObj.nChannels
+                    self.dataOut.nChannels = self.systemHeaderObj.nChannels
-                    self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
+                    self.dataOut.nHeights = self.processingHeaderObj.nHeights
-                    self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
+                    self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
-                    self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
+                    self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
-                    self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
+                    self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
-                    self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
+                    self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
-                    self.dataOutObj.flagTimeBlock = self.flagTimeBlock
+                    self.dataOut.flagTimeBlock = self.flagTimeBlock
-                    self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
+                    self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
-                    self.dataOutObj.ippSeconds = self.ippSeconds
+                    self.dataOut.ippSeconds = self.ippSeconds
-                    self.dataOutObj.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
+                    self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
-                    self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
+                    self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
-                    self.dataOutObj.flagShiftFFT = False
+                    self.dataOut.flagShiftFFT = False
                     if self.processingHeaderObj.code != None:
-                        self.dataOutObj.nCode = self.processingHeaderObj.nCode
+                        self.dataOut.nCode = self.processingHeaderObj.nCode
-                        self.dataOutObj.nBaud = self.processingHeaderObj.nBaud
+                        self.dataOut.nBaud = self.processingHeaderObj.nBaud
-                        self.dataOutObj.code = self.processingHeaderObj.code
+                        self.dataOut.code = self.processingHeaderObj.code
                     self.profileIndex += 1
-                    self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
+                    self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
-                    self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
+                    self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
-                    self.dataOutObj.flagNoData = False
+                    self.dataOut.flagNoData = False
-            #        print self.profileIndex, self.dataOutObj.utctime
+            #        print self.profileIndex, self.dataOut.utctime
             #        if self.profileIndex == 800:
             #            a=1
-                    return self.dataOutObj.data
+                    return self.dataOut.data
             class VoltageWriter(JRODataWriter):
                 shapeBuffer = None
-                def __init__(self, dataOutObj=None):
+                def __init__(self, dataOut=None):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
-                        self.dataOutObj
+                        self.dataOut
                     Return: None
                     """
-                    if dataOutObj == None:
+                    if dataOut == None:
-                        dataOutObj = Voltage()
+                        dataOut = Voltage()
-                    if not( isinstance(dataOutObj, Voltage) ):
+                    if not( isinstance(dataOut, Voltage) ):
-                        raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
+                        raise ValueError, "in VoltageReader, dataOut must be an Spectra class object"
-                    self.dataOutObj = dataOutObj
+                    self.dataOut = dataOut
                     self.nTotalBlocks = 0
                     self.profileIndex = 0
-                    self.__isConfig = False
+                    self.isConfig = False
                     self.fp = None
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
-                    if self.dataOutObj.flagNoData:
+                    if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
-                    if self.dataOutObj.flagTimeBlock:
+                    if self.dataOut.flagTimeBlock:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                     if self.profileIndex == 0:
                         self.getBasicHeader()
-                    self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
+                    self.datablock[:,self.profileIndex,:] = self.dataOut.data
                     self.profileIndex += 1
                     for index in range(len(dtypeList)):
-                        if self.dataOutObj.dtype == dtypeList[index]:
+                        if self.dataOut.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
-                    if self.dataOutObj.flagDecodeData:
+                    if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
-                    if self.dataOutObj.flagDeflipData:
+                    if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
-                    if self.dataOutObj.code != None:
+                    if self.dataOut.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
-                    if self.dataOutObj.nCohInt > 1:
+                    if self.dataOut.nCohInt > 1:
                         processFlags += PROCFLAG.COHERENT_INTEGRATION
                     return processFlags
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList = [1,2,4,8,4,8]
                     for index in range(len(dtypeList)):
-                        if self.dataOutObj.dtype == dtypeList[index]:
+                        if self.dataOut.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
-                    blocksize = int(self.dataOutObj.nHeights * self.dataOutObj.nChannels * self.dataOutObj.nProfiles * datatypeValue * 2)
+                    blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.dataOut.nProfiles * datatypeValue * 2)
                     return blocksize
                         None
                     """
-                    self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
+                    self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
-                    self.systemHeaderObj.nChannels = self.dataOutObj.nChannels
+                    self.systemHeaderObj.nChannels = self.dataOut.nChannels
-                    self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
+                    self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.getBasicHeader()
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
-                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
+                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
-                    self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt
+                    self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
                     self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
                     self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
-                    if self.dataOutObj.code != None:
+                    if self.dataOut.code != None:
-                        self.processingHeaderObj.code = self.dataOutObj.code
+                        self.processingHeaderObj.code = self.dataOut.code
-                        self.processingHeaderObj.nCode = self.dataOutObj.nCode
+                        self.processingHeaderObj.nCode = self.dataOut.nCode
-                        self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
+                        self.processingHeaderObj.nBaud = self.dataOut.nBaud
-                        codesize = int(8 + 4 * self.dataOutObj.nCode * self.dataOutObj.nBaud)
+                        codesize = int(8 + 4 * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += codesize
                     if self.processingHeaderObj.nWindows != 0:
-                        self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
-                        self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
-                        self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
+                        self.processingHeaderObj.nHeights = self.dataOut.nHeights
-                        self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
+                        self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                         processingHeaderSize += 12
                     self.processingHeaderObj.size = processingHeaderSize
                 optchar = "P"
-                dataOutObj = None
+                dataOut = None
                 nRdChannels = None
                 rdPairList = []
-                def __init__(self, dataOutObj=None):
+                def __init__(self, dataOut=None):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Inputs:
-                        dataOutObj    :    Objeto de la clase Spectra. Este objeto sera utilizado para
+                        dataOut    :    Objeto de la clase Spectra. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           Si este parametro no es pasado se creara uno internamente.
                     Affected:
-                        self.dataOutObj
+                        self.dataOut
                     Return      : None
                     """
-                    self.__isConfig = False
+                    self.isConfig = False
                     self.pts2read_SelfSpectra = 0
                         self.pts2read_CrossSpectra
                         self.pts2read_DCchannels
                         self.blocksize
-                        self.dataOutObj.nChannels
+                        self.dataOut.nChannels
-                        self.dataOutObj.nPairs
+                        self.dataOut.nPairs
                     Return:
                         None
 :    Si hizo una buena copia del buffer
                     Affected:
-                        self.dataOutObj
+                        self.dataOut
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.data_dc == None:
-                        self.dataOutObj.flagNoData = True
+                        self.dataOut.flagNoData = True
                         return 0
-                    self.dataOutObj.data_spc = self.data_spc
+                    self.dataOut.data_spc = self.data_spc
-                    self.dataOutObj.data_cspc = self.data_cspc
+                    self.dataOut.data_cspc = self.data_cspc
-                    self.dataOutObj.data_dc = self.data_dc
+                    self.dataOut.data_dc = self.data_dc
-                    self.dataOutObj.flagTimeBlock = self.flagTimeBlock
+                    self.dataOut.flagTimeBlock = self.flagTimeBlock
-                    self.dataOutObj.flagNoData = False
+                    self.dataOut.flagNoData = False
-                    self.dataOutObj.dtype = self.dtype
+                    self.dataOut.dtype = self.dtype
-                    self.dataOutObj.nChannels = self.nRdChannels
+                    self.dataOut.nChannels = self.nRdChannels
-                    self.dataOutObj.nPairs = self.nRdPairs
+                    self.dataOut.nPairs = self.nRdPairs
-                    self.dataOutObj.pairsList = self.rdPairList
+                    self.dataOut.pairsList = self.rdPairList
-                    self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
+                    self.dataOut.nHeights = self.processingHeaderObj.nHeights
-                    self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
+                    self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
-                    self.dataOutObj.nFFTPoints = self.processingHeaderObj.profilesPerBlock
+                    self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
-                    self.dataOutObj.nIncohInt = self.processingHeaderObj.nIncohInt
+                    self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
-                    self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
+                    self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
-                    self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
+                    self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
-                    self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
+                    self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
-                    self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
+                    self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
-                    self.dataOutObj.ippSeconds = self.ippSeconds
+                    self.dataOut.ippSeconds = self.ippSeconds
-                    self.dataOutObj.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOutObj.nFFTPoints
+                    self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints
-                    self.dataOutObj.flagShiftFFT = self.processingHeaderObj.shif_fft
+                    self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
             #        self.profileIndex += 1
-                    self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
+                    self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
-                    self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
+                    self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
-                    return self.dataOutObj.data_spc
+                    return self.dataOut.data_spc
             class SpectraWriter(JRODataWriter):
                 data_dc = None
-            #    dataOutObj = None
+            #    dataOut = None
-                def __init__(self, dataOutObj=None):
+                def __init__(self, dataOut=None):
                     """
                     Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
                     Affected:
-                        self.dataOutObj
+                        self.dataOut
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                     Return: None
                     """
-                    if dataOutObj == None:
+                    if dataOut == None:
-                        dataOutObj = Spectra()
+                        dataOut = Spectra()
-                    if not( isinstance(dataOutObj, Spectra) ):
+                    if not( isinstance(dataOut, Spectra) ):
-                        raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
+                        raise ValueError, "in SpectraReader, dataOut must be an Spectra class object"
-                    self.dataOutObj = dataOutObj
+                    self.dataOut = dataOut
-                    self.__isConfig = False
+                    self.isConfig = False
                     self.nTotalBlocks = 0
                     Return: None
                     """
-                    self.shape_spc_Buffer = (self.dataOutObj.nChannels,
+                    self.shape_spc_Buffer = (self.dataOut.nChannels,
                                              self.processingHeaderObj.nHeights,
                                              self.processingHeaderObj.profilesPerBlock)
-                    self.shape_cspc_Buffer = (self.dataOutObj.nPairs,
+                    self.shape_cspc_Buffer = (self.dataOut.nPairs,
                                               self.processingHeaderObj.nHeights,
                                               self.processingHeaderObj.profilesPerBlock)
-                    self.shape_dc_Buffer = (self.dataOutObj.nChannels,
+                    self.shape_dc_Buffer = (self.dataOut.nChannels,
                                             self.processingHeaderObj.nHeights)
 :    Si se escribio la data de un bloque en un file
                     """
-                    if self.dataOutObj.flagNoData:
+                    if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
-                    if self.dataOutObj.flagTimeBlock:
+                    if self.dataOut.flagTimeBlock:
                         self.data_spc.fill(0)
                         self.data_cspc.fill(0)
                         self.data_dc.fill(0)
                     if self.flagIsNewFile == 0:
                         self.getBasicHeader()
-                    self.data_spc = self.dataOutObj.data_spc
+                    self.data_spc = self.dataOut.data_spc
-                    self.data_cspc = self.dataOutObj.data_cspc
+                    self.data_cspc = self.dataOut.data_cspc
-                    self.data_dc = self.dataOutObj.data_dc
+                    self.data_dc = self.dataOut.data_dc
                     # #self.processingHeaderObj.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
                     for index in range(len(dtypeList)):
-                        if self.dataOutObj.dtype == dtypeList[index]:
+                        if self.dataOut.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
-                    if self.dataOutObj.flagDecodeData:
+                    if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
-                    if self.dataOutObj.flagDeflipData:
+                    if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
-                    if self.dataOutObj.code != None:
+                    if self.dataOut.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
-                    if self.dataOutObj.nIncohInt > 1:
+                    if self.dataOut.nIncohInt > 1:
                         processFlags += PROCFLAG.INCOHERENT_INTEGRATION
-                    if self.dataOutObj.data_dc != None:
+                    if self.dataOut.data_dc != None:
                         processFlags += PROCFLAG.SAVE_CHANNELS_DC
                     return processFlags
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList = [1,2,4,8,4,8]
                     for index in range(len(dtypeList)):
-                        if self.dataOutObj.dtype == dtypeList[index]:
+                        if self.dataOut.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
-                    pts2write = self.dataOutObj.nHeights * self.dataOutObj.nFFTPoints
+                    pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
-                    pts2write_SelfSpectra = int(self.dataOutObj.nChannels * pts2write)
+                    pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
                     blocksize = (pts2write_SelfSpectra*datatypeValue)
-                    if self.dataOutObj.data_cspc != None:
+                    if self.dataOut.data_cspc != None:
-                        pts2write_CrossSpectra = int(self.dataOutObj.nPairs * pts2write)
+                        pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
                         blocksize += (pts2write_CrossSpectra*datatypeValue*2)
-                    if self.dataOutObj.data_dc != None:
+                    if self.dataOut.data_dc != None:
-                        pts2write_DCchannels = int(self.dataOutObj.nChannels * self.dataOutObj.nHeights)
+                        pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
                         blocksize += (pts2write_DCchannels*datatypeValue*2)
                     blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
                         None
                     """
-                    self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
+                    self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
-                    self.systemHeaderObj.nChannels = self.dataOutObj.nChannels
+                    self.systemHeaderObj.nChannels = self.dataOut.nChannels
-                    self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
+                    self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.getBasicHeader()
                     processingHeaderSize = 40 # bytes
                     self.processingHeaderObj.dtype = 0 # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
-                    self.processingHeaderObj.profilesPerBlock = self.dataOutObj.nFFTPoints
+                    self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
-                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
+                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
-                    self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt# Se requiere para determinar el valor de timeInterval
+                    self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
-                    self.processingHeaderObj.nIncohInt = self.dataOutObj.nIncohInt
+                    self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
-                    self.processingHeaderObj.totalSpectra = self.dataOutObj.nPairs + self.dataOutObj.nChannels
+                    self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
                     if self.processingHeaderObj.totalSpectra > 0:
                         channelList = []
-                        for channel in range(self.dataOutObj.nChannels):
+                        for channel in range(self.dataOut.nChannels):
                             channelList.append(channel)
                             channelList.append(channel)
                         pairsList = []
-                        for pair in self.dataOutObj.pairsList:
+                        for pair in self.dataOut.pairsList:
                             pairsList.append(pair[0])
                             pairsList.append(pair[1])
                         spectraComb = channelList + pairsList
                         sizeOfSpcComb = len(spectraComb)
                         processingHeaderSize += sizeOfSpcComb
-                    if self.dataOutObj.code != None:
+                    if self.dataOut.code != None:
-                        self.processingHeaderObj.code = self.dataOutObj.code
+                        self.processingHeaderObj.code = self.dataOut.code
-                        self.processingHeaderObj.nCode = self.dataOutObj.nCode
+                        self.processingHeaderObj.nCode = self.dataOut.nCode
-                        self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
+                        self.processingHeaderObj.nBaud = self.dataOut.nBaud
                         nCodeSize = 4 # bytes
                         nBaudSize = 4 # bytes
                         codeSize = 4 # bytes
-                        sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOutObj.nCode * self.dataOutObj.nBaud)
+                        sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += sizeOfCode
                     if self.processingHeaderObj.nWindows != 0:
-                        self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
-                        self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
-                        self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
+                        self.processingHeaderObj.nHeights = self.dataOut.nHeights
-                        self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
+                        self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                         sizeOfFirstHeight = 4
                         sizeOfdeltaHeight = 4
                         sizeOfnHeights = 4
                 i=0
-                def __init__(self, dataOutObj):
+                def __init__(self, dataOut):
                     self.wrObj = FITS()
-                    self.dataOutObj = dataOutObj
+                    self.dataOut = dataOut
                 def isNumber(str):
                     """
                     self.setFile = 0
                 def putData(self):
-                  # self.wrObj.writeHeader(nChannels=self.dataOutObj.nChannels, nFFTPoints=self.dataOutObj.nFFTPoints)
+                  # self.wrObj.writeHeader(nChannels=self.dataOut.nChannels, nFFTPoints=self.dataOut.nFFTPoints)
-                    #name = self.dataOutObj.utctime
+                    #name = self.dataOut.utctime
-                    name= time.localtime( self.dataOutObj.utctime)
+                    name= time.localtime( self.dataOut.utctime)
                     ext=".fits"
                     #folder='D%4.4d%3.3d'%(name.tm_year,name.tm_yday)
                     subfolder = 'D%4.4d%3.3d' % (name.tm_year,name.tm_yday)
                     filename = os.path.join(self.wrpath,subfolder, file)
-                   # print self.dataOutObj.ippSeconds
+                   # print self.dataOut.ippSeconds
-                    freq=numpy.arange(-1*self.dataOutObj.nHeights/2.,self.dataOutObj.nHeights/2.)/(2*self.dataOutObj.ippSeconds)
+                    freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)/(2*self.dataOut.ippSeconds)
-                    col1=self.wrObj.setColF(name="freq", format=str(self.dataOutObj.nFFTPoints)+'E', array=freq)
+                    col1=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
-                    col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[0,:]))
+                    col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[0,:]))
-                    col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[1,:]))
+                    col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[1,:]))
-                    col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[2,:]))
+                    col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[2,:]))
-                    col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[3,:]))
+                    col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[3,:]))
-                    col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[4,:]))
+                    col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[4,:]))
-                    col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[5,:]))
+                    col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[5,:]))
-                    col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[6,:]))
+                    col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[6,:]))
-                    col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[7,:]))
+                    col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[7,:]))
                     #n=numpy.arange((100))
-                    n=self.dataOutObj.data_spc[6,:]
+                    n=self.dataOut.data_spc[6,:]
                     a=self.wrObj.cFImage(n)
                     b=self.wrObj.Ctable(col1,col2,col3,col4,col5,col6,col7,col8,col9)
                     self.wrObj.CFile(a,b)

schainpy/model/jroprocessing.py +34 -34

                         objId    :    identificador del objeto, necesario para ejecutar la operacion
                     """
-                    self.object[objId] = object
+                    self.objectDict[objId] = object
                     return objId
                 """
                 Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
-                y necesiten acumular información previa de los datos a procesar. De preferencia usar un buffer de
+                y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
                 acumulacion dentro de esta clase
-                Ejemplo: Integraciones coherentes, necesita la información previa de los n perfiles anteriores (bufffer)
+                Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
                 """
                 def __init__(self):
+                    self.objectDict = {}
                     pass
-                def setup(self, dataInObj=None, dataOutObj=None):
+                def setup(self, dataIn=None, dataOut=None):
-                    self.dataInObj = dataInObj
+                    self.dataIn = dataIn
-                    if self.dataOutObj == None:
+                    if self.dataOut == None:
-                        dataOutObj = Voltage()
+                        dataOut = Voltage()
-                    self.dataOutObj = dataOutObj
+                    self.dataOut = dataOut
-                    return self.dataOutObj
+                    return self.dataOut
                 def init(self):
-                    if self.dataInObj.isEmpty():
+                    if self.dataIn.isEmpty():
                         return 0
-                    self.dataOutObj.copy(self.dataInObj)
+                    self.dataOut.copy(self.dataIn)
-                    # No necesita copiar en cada init() los atributos de dataInObj
+                    # No necesita copiar en cada init() los atributos de dataIn
                     # la copia deberia hacerse por cada nuevo bloque de datos
                 def selectChannels(self, channelList):
-                    if self.dataInObj.isEmpty():
+                    if self.dataIn.isEmpty():
                         return 0
                     self.selectChannelsByIndex(channelList)
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
-                        self.dataOutObj.data
+                        self.dataOut.data
-                        self.dataOutObj.channelIndexList
+                        self.dataOut.channelIndexList
-                        self.dataOutObj.nChannels
+                        self.dataOut.nChannels
-                        self.dataOutObj.m_ProcessingHeader.totalSpectra
+                        self.dataOut.m_ProcessingHeader.totalSpectra
-                        self.dataOutObj.systemHeaderObj.numChannels
+                        self.dataOut.systemHeaderObj.numChannels
-                        self.dataOutObj.m_ProcessingHeader.blockSize
+                        self.dataOut.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channel in channelIndexList:
-                        if channel not in self.dataOutObj.channelIndexList:
+                        if channel not in self.dataOut.channelIndexList:
                             raise ValueError, "The value %d in channelIndexList is not valid" %channel
                     nChannels = len(channelIndexList)
-                    data = self.dataOutObj.data[channelIndexList,:]
+                    data = self.dataOut.data[channelIndexList,:]
-                    self.dataOutObj.data = data
+                    self.dataOut.data = data
-                    self.dataOutObj.channelIndexList = channelIndexList
+                    self.dataOut.channelIndexList = channelIndexList
-                    self.dataOutObj.channelList = [self.dataOutObj.channelList[i] for i in channelIndexList]
+                    self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
-                    self.dataOutObj.nChannels = nChannels
+                    self.dataOut.nChannels = nChannels
                     return 1
                     else:
                         self.__initime += deltatime
-                return avgdata, avgdatatime
+                    return avgdata, avgdatatime
                 def run(self, dataOut, nCohInt=None, timeInterval=None, overlapping=False):
                     avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
-            #        self.dataOutObj.timeInterval *= nCohInt
+            #        self.dataOut.timeInterval *= nCohInt
-                    self.dataOutObj.flagNoData = True
+                    self.dataOut.flagNoData = True
                     if self.__dataReady:
-                        dataOutObj.data = avgdata
+                        dataOut.data = avgdata
-                        dataOutObj.timeInterval *= self.nCohInt
+                        dataOut.timeInterval *= self.nCohInt
-                        dataOutObj.nCohInt *= self.nCohInt
+                        dataOut.nCohInt *= self.nCohInt
-                        dataOutObj.utctime = avgdatatime
+                        dataOut.utctime = avgdatatime
-                        dataOutObj.flagNoData = False
  No newline at end of file
+                        dataOut.flagNoData = False
  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