schain Commit - r1082:831a23834344 · Jicamarca Repository

formatting

José Chávez -

r1082:831a23834344

parent child

Context file:

r1082:831a23834344

Collapse all files

schainpy/controller.py +41 -25

                 'Spectra': '.pdata'
             }
             def MPProject(project, n=cpu_count()):
                 '''
                 Project wrapper to run schain in n processes
                     time.sleep(3)
             class ParameterConf():
                 id = None
                     print 'Parameter[%s]: name = %s, value = %s, format = %s' % (self.id, self.name, self.value, self.format)
             class OperationConf():
                 id = None
                     self.priority = None
                     self.type = 'self'
                 def __getNewId(self):
                     return int(self.id) * 10 + len(self.parmConfObjList) + 1
                     return value
                 def getKwargs(self):
                     kwargs = {}
                 def createObject(self, plotter_queue=None):
                     if self.type == 'self':
                         raise ValueError, 'This operation type cannot be created'
                 def updateId(self, new_id, parentId=parentId):
                     new_id = int(parentId) * 10 + (int(self.id) % 10)
                     new_inputId = int(parentId) * 10 + (int(self.inputId) % 10)
                     self.id = str(new_id)
                     self.inputId = str(new_inputId)
                 def getInputId(self):
                     return self.inputId
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                 def getKwargs(self):
                     opObj = self.opConfObjList[0]
                         if opConfObj.type == 'self' and self.name == 'run':
                             continue
                         elif opConfObj.type == 'self':
-                            procUnitObj.addOperationKwargs(opConfObj.id, **opConfObj.getKwargs())
+                            procUnitObj.addOperationKwargs(
+                                opConfObj.id, **opConfObj.getKwargs())
                             continue
                         opObj = opConfObj.createObject(plotter_queue)
                     return
             class ReadUnitConf(ProcUnitConf):
                 path = None
                             self.name = '%sReader' % (datatype)
                         self.datatype = self.name.replace('Reader', '')
-                    attrs = ('path', 'startDate', 'endDate', 'startTime', 'endTime', 'parentId')
+                    attrs = ('path', 'startDate', 'endDate',
+                             'startTime', 'endTime', 'parentId')
                     for attr in attrs:
                         if attr in kwargs:
                     opObj = self.addOperation(name='run', optype='self')
                     if self.server is None:
-                        opObj.addParameter(name='datatype', value=self.datatype, format='str')
+                        opObj.addParameter(
+                            name='datatype', value=self.datatype, format='str')
                         opObj.addParameter(name='path', value=self.path, format='str')
-                        opObj.addParameter(name='startDate', value=self.startDate, format='date')
+                        opObj.addParameter(
-                        opObj.addParameter(name='endDate', value=self.endDate, format='date')
+                            name='startDate', value=self.startDate, format='date')
-                        opObj.addParameter(name='startTime', value=self.startTime, format='time')
+                        opObj.addParameter(
-                        opObj.addParameter(name='endTime', value=self.endTime, format='time')
+                            name='endDate', value=self.endDate, format='date')
+                        opObj.addParameter(
+                            name='startTime', value=self.startTime, format='time')
+                        opObj.addParameter(
+                            name='endTime', value=self.endTime, format='time')
                         for key, value in kwargs.items():
-                            opObj.addParameter(name=key, value=value, format=type(value).__name__)
+                            opObj.addParameter(name=key, value=value,
+                                               format=type(value).__name__)
                     else:
                         opObj.addParameter(name='server', value=self.server, format='str')
                     return opObj
                 def updateRunOperation(self, **kwargs):
                     opObj.addParameter(name='datatype', value=self.datatype, format='str')
                     opObj.addParameter(name='path', value=self.path, format='str')
-                    opObj.addParameter(name='startDate', value=self.startDate, format='date')
+                    opObj.addParameter(
+                        name='startDate', value=self.startDate, format='date')
                     opObj.addParameter(name='endDate', value=self.endDate, format='date')
-                    opObj.addParameter(name='startTime', value=self.startTime, format='time')
+                    opObj.addParameter(
+                        name='startTime', value=self.startTime, format='time')
                     opObj.addParameter(name='endTime', value=self.endTime, format='time')
                     for key, value in kwargs.items():
-                        opObj.addParameter(name=key, value=value, format=type(value).__name__)
+                        opObj.addParameter(name=key, value=value,
+                                           format=type(value).__name__)
                     return opObj
                             self.startTime = opConfObj.getParameterValue('startTime')
                             self.endTime = opConfObj.getParameterValue('endTime')
             class Project(Process):
                 id = None
                         idReadUnit = str(id)
                     readUnitConfObj = ReadUnitConf()
-                    readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
+                    readUnitConfObj.setup(idReadUnit, name, datatype,
+                                          parentId=self.id, **kwargs)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     idProcUnit = self.__getNewId()
                     procUnitConfObj = ProcUnitConf()
-                    procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
+                    procUnitConfObj.setup(idProcUnit, name, datatype,
+                                          inputId, parentId=self.id)
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     self.name = self.projectElement.get('name')
                     self.description = self.projectElement.get('description')
-                    readUnitElementList = self.projectElement.iter(ReadUnitConf().getElementName())
+                    readUnitElementList = self.projectElement.iter(
+                        ReadUnitConf().getElementName())
                     for readUnitElement in readUnitElementList:
                         readUnitConfObj = ReadUnitConf()
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
-                    procUnitElementList = self.projectElement.iter(ProcUnitConf().getElementName())
+                    procUnitElementList = self.projectElement.iter(
+                        ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                     if not send_email:
                         return
-                    subject =  'SChain v%s: Error running %s\n' %(schainpy.__version__, procUnitConfObj.name)
+                    subject = 'SChain v%s: Error running %s\n' % (
+                        schainpy.__version__, procUnitConfObj.name)
-                    subtitle = '%s: %s\n' %(procUnitConfObj.getElementName() ,procUnitConfObj.name)
+                    subtitle = '%s: %s\n' % (
-                    subtitle += 'Hostname: %s\n' %socket.gethostbyname(socket.gethostname())
+                        procUnitConfObj.getElementName(), procUnitConfObj.name)
+                    subtitle += 'Hostname: %s\n' % socket.gethostbyname(
+                        socket.gethostname())
                     subtitle += 'Working directory: %s\n' % os.path.abspath('./')
                     subtitle += 'Configuration file: %s\n' % self.filename
                     subtitle += 'Time: %s\n' % str(datetime.datetime.now())

schainpy/model/io/jroIO_voltage.py +63 -37

             from StringIO import StringIO
             # from _sha import blocksize
             class VoltageReader(JRODataReader, ProcessingUnit):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                     return 0
                 def getBlockDimension(self):
                     """
                         Obtiene la cantidad de puntos a leer por cada bloque de datos
                         Return:
                             None
                     """
-                    pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
+                    pts2read = self.processingHeaderObj.profilesPerBlock * \
+                        self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
                     self.blocksize = pts2read
                 def readBlock(self):
                     """
                         readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
                     junk = numpy.fromfile(self.fp, self.dtype, self.blocksize)
                     try:
-                        junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
+                        junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
+                                             self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     except:
                         # print "The read block (%3d) has not enough data" %self.nReadBlocks
                         if self.waitDataBlock(pointer_location=current_pointer_location):
                             junk = numpy.fromfile(self.fp, self.dtype, self.blocksize)
-                            junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
+                            junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
+                                                 self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     #             return 0
                     # Dimensions : nChannels, nProfiles, nSamples
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
-                    self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) *self.processingHeaderObj.deltaHeight +  self.processingHeaderObj.firstHeight
+                    self.dataOut.heightList = numpy.arange(
+                        self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
-                    self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
+                    # asumo q la data no esta decodificada
+                    self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode
-                    self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data no esta sin flip
+                    # asumo q la data no esta sin flip
+                    self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip
                     self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
                         return
                     if self.nTxs < 1 and self.processingHeaderObj.profilesPerBlock % (1. / self.nTxs) != 0:
-                        raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" %(1./self.nTxs, self.processingHeaderObj.profilesPerBlock)
+                        raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" % (
+. / self.nTxs, self.processingHeaderObj.profilesPerBlock)
                     if self.nTxs > 1 and self.processingHeaderObj.nHeights % self.nTxs != 0:
-                        raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" %(self.nTxs, self.processingHeaderObj.nHeights)
+                        raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" % (
+                            self.nTxs, self.processingHeaderObj.nHeights)
-                    self.datablock = self.datablock.reshape((self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock*self.nTxs, self.processingHeaderObj.nHeights/self.nTxs))
+                    self.datablock = self.datablock.reshape(
+                        (self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock * self.nTxs, self.processingHeaderObj.nHeights / self.nTxs))
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock * self.nTxs
-                    self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights/self.nTxs) *self.processingHeaderObj.deltaHeight +  self.processingHeaderObj.firstHeight
+                    self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights / self.nTxs) * \
+                        self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                     return
                     self.firstHeaderSize = self.basicHeaderObj.size
-                    datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
+                    datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
+                                               PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                     elif datatype == 1:
                     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.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + \
+                        self.firstHeaderSize + self.basicHeaderSize * \
+                        (self.processingHeaderObj.dataBlocksPerFile - 1)
                     #        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
                     #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def getFromServer(self):
                     self.flagDiscontinuousBlock = 0
                     self.profileIndex = 0
                     timestamp = self.basicHeaderObj.get_datatime()
                     print '[Reading] - Block {} - {}'.format(self.nTotalBlocks, timestamp)
                     current_pointer_location = self.blockPointer
-                    junk = numpy.fromstring( block[self.blockPointer:], self.dtype, self.blocksize )
+                    junk = numpy.fromstring(
+                        block[self.blockPointer:], self.dtype, self.blocksize)
                     try:
-                        junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
+                        junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
+                                             self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     except:
                         # print "The read block (%3d) has not enough data" %self.nReadBlocks
                         if self.waitDataBlock(pointer_location=current_pointer_location):
-                            junk = numpy.fromstring( block[self.blockPointer:], self.dtype, self.blocksize )
+                            junk = numpy.fromstring(
-                            junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
+                                block[self.blockPointer:], self.dtype, self.blocksize)
+                            junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
+                                                 self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     #               return 0
                     # Dimensions : nChannels, nProfiles, nSamples
                     junk = numpy.transpose(junk, (2, 0, 1))
                     self.datablock = junk['real'] + junk['imag'] * 1j
                     self.profileIndex = 0
-                    if self.selBlocksize == None: self.selBlocksize = self.dataOut.nProfiles
+                    if self.selBlocksize == None:
+                        self.selBlocksize = self.dataOut.nProfiles
                     if self.selBlocktime != None:
                         if self.dataOut.nCohInt is not None:
                             nCohInt = self.dataOut.nCohInt
                         else:
                             nCohInt = 1
-                        self.selBlocksize = int(self.dataOut.nProfiles*round(self.selBlocktime/(nCohInt*self.dataOut.ippSeconds*self.dataOut.nProfiles)))
+                        self.selBlocksize = int(self.dataOut.nProfiles * round(self.selBlocktime / (
-                    self.dataOut.data = self.datablock[:,self.profileIndex:self.profileIndex+self.selBlocksize,:]
+                            nCohInt * self.dataOut.ippSeconds * self.dataOut.nProfiles)))
+                    self.dataOut.data = self.datablock[:,
+                                                       self.profileIndex:self.profileIndex + self.selBlocksize, :]
                     datasize = self.dataOut.data.shape[1]
                     if datasize < self.selBlocksize:
-                        buffer = numpy.zeros((self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype = 'complex')
+                        buffer = numpy.zeros(
+                            (self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype='complex')
                         buffer[:, :datasize, :] = self.dataOut.data
                         self.dataOut.data = buffer
                         self.profileIndex = blockIndex
                         """
                             Return a block
                         """
-                        if self.selBlocksize == None:   self.selBlocksize = self.dataOut.nProfiles
+                        if self.selBlocksize == None:
+                            self.selBlocksize = self.dataOut.nProfiles
                         if self.selBlocktime != None:
                             if self.dataOut.nCohInt is not None:
                                 nCohInt = self.dataOut.nCohInt
                             else:
                                 nCohInt = 1
-                            self.selBlocksize = int(self.dataOut.nProfiles*round(self.selBlocktime/(nCohInt*self.dataOut.ippSeconds*self.dataOut.nProfiles)))
+                            self.selBlocksize = int(self.dataOut.nProfiles * round(self.selBlocktime / (
+                                nCohInt * self.dataOut.ippSeconds * self.dataOut.nProfiles)))
-                        self.dataOut.data = self.datablock[:,self.profileIndex:self.profileIndex+self.selBlocksize,:]
+                        self.dataOut.data = self.datablock[:,
+                                                           self.profileIndex:self.profileIndex + self.selBlocksize, :]
                         self.profileIndex += self.selBlocksize
                         datasize = self.dataOut.data.shape[1]
                         if datasize < self.selBlocksize:
-                            buffer = numpy.zeros((self.dataOut.data.shape[0],self.selBlocksize,self.dataOut.data.shape[2]), dtype = 'complex')
+                            buffer = numpy.zeros(
+                                (self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype='complex')
                             buffer[:, :datasize, :] = self.dataOut.data
                             while datasize < self.selBlocksize:  # Not enough profiles to fill the block
                                 blockIndex = self.selBlocksize - datasize
                                 datablock1 = self.datablock[:, :blockIndex, :]
-                                buffer[:,datasize:datasize+datablock1.shape[1],:] = datablock1
+                                buffer[:, datasize:datasize +
+                                       datablock1.shape[1], :] = datablock1
                                 datasize += datablock1.shape[1]
                             self.dataOut.data = buffer
                     return self.dataOut.data
             class VoltageWriter(JRODataWriter, Operation):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 shapeBuffer = None
                 def __init__(self, **kwargs):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                         return 1
                     return 0
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     dtype_width = self.getDtypeWidth()
-                    blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.profilesPerBlock * dtype_width * 2)
+                    blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels *
+                                    self.profilesPerBlock * dtype_width * 2)
                     return blocksize
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
-                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
+                    # podria ser 1 o self.dataOut.processingHeaderObj.nWindows
+                    self.processingHeaderObj.nWindows = 1
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
-                    self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
+                    # Cuando la data de origen es de tipo Voltage
-                    self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
+                    self.processingHeaderObj.nIncohInt = 1
+                    # Cuando la data de origen es de tipo Voltage
+                    self.processingHeaderObj.totalSpectra = 0
                     if self.dataOut.code is not None:
                         self.processingHeaderObj.code = self.dataOut.code
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
-                        self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
+                        self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - \
+                            self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights

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