Python GenomeInfo.getChrLen方法代码示例

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
 def _checkValidStart(self, chr, start):
     if start < 0:
         raise InvalidFormatError('Error: start position is negative: %s' % start)
 
     if self.genome and \
         GenomeInfo.isValidChr(self.genome, chr) and \
             start > GenomeInfo.getChrLen(self.genome, chr):
                 raise InvalidFormatError('Error: start position is larger than chromosome size (%s) < %d' % \
                                          (GenomeInfo.getChrLen(self.genome, chr), start))
     return start

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
 def _checkValidEnd(self, chr, end, start=None):
     if end < 0:
         raise InvalidFormatError('Error: end position is negative: %s' % end)
     
     if self.genome and \
         GenomeInfo.isValidChr(self.genome, chr) and \
             end-1 > GenomeInfo.getChrLen(self.genome, chr):
                 raise InvalidFormatError('Error: end position is larger than chromosome size (%s)' % \
                                          GenomeInfo.getChrLen(self.genome, chr))
     if start is not None and end <= start:
             raise InvalidFormatError('Error: end position (end-exclusive) is smaller than or equal to start position: %d <= %d' % (end, start))
     
     return end

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
 def _getBoundingRegionTupleList(self, case, sortedAssertElList):
     boundingRegions = [br for br in sorted(case.boundingRegionsAssertList) if br.region.chr is not None]
     if len(boundingRegions) > 0:
         return [BoundingRegionTuple(GenomeRegion(self.GENOME, chr=br.region.chr, \
                                                  start=br.region.start if br.region.start is not None else 0, \
                                                  end=br.region.end if br.region.end is not None else \
                                                      GenomeInfo.getChrLen(self.GENOME, br.region.chr)), br.elCount)
                 for br in boundingRegions]
     else:
         totChrList = [ge.chr for ge in sortedAssertElList]
         chrBrList = OrderedDict( [ (i, totChrList.count(i)) for i in sorted(set(totChrList)) ] )
         return [BoundingRegionTuple(GenomeRegion(self.GENOME, chr=chr, start=0, \
                                                  end=GenomeInfo.getChrLen(self.GENOME, chr)), elCount) \
                 for chr, elCount in chrBrList.iteritems()]

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
    def __iter__(self):
        brShelve1 = self._getBoundingRegionShelve(self._trackName1)
        brShelve2 = self._getBoundingRegionShelve(self._trackName2)
        
        for chr in GenomeInfo.getExtendedChrList(self.genome):
            if brShelve1 is None:
                yield GenomeRegion(self.genome, chr, 0, GenomeInfo.getChrLen(self.genome, chr))
            else:
                brList1 = brShelve1.getAllBoundingRegions(chr)
                allBrsAreWholeChrs1 = self._commonAllBoundingRegionsAreWholeChr(brShelve1)
                allBrsAreWholeChrs2 = self._commonAllBoundingRegionsAreWholeChr(brShelve2) \
                    if brShelve2 is not None else False

                if brShelve2 is None or \
                    (allBrsAreWholeChrs2 and not allBrsAreWholeChrs1):
                    for reg in brList1:
                        yield reg
                else:
                    brList2 = brShelve2.getAllBoundingRegions(chr)
                    if allBrsAreWholeChrs1 and not allBrsAreWholeChrs2:
                        for reg in brList2:
                            yield reg
                    else:
                        for reg in self.getAllIntersectingRegions(self.genome, chr, brList1, brList2):
                            yield reg

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
    def _createPreProcFiles(self):
        collector = TrackInfoDataCollector(self._genome, self._trackName)
        collector.updateMetaDataForFinalization(self._geSource.getFileSuffix(), self._geSource.getPrefixList(), \
                                                self._geSource.getValDataType(), self._geSource.getValDim(), \
                                                self._geSource.getEdgeWeightDataType(), self._geSource.getEdgeWeightDim(), \
                                                self._geSource.hasUndirectedEdges(),
                                                self._geSource.getVersion(), PreProcessUtils.constructId(self._geSource))

        if collector.getNumElements(self._chr, self._allowOverlaps) == 0:
            return
        
        if self._mode != 'Real':
            for ge in self._geSource:
                pass
            return
        
        dirPath = createDirPath(self._trackName, self._genome, self._chr, self._allowOverlaps)

        dir = OutputDirectory(dirPath, collector.getPrefixList(self._allowOverlaps), \
                              collector.getNumElements(self._chr, self._allowOverlaps),\
                              GenomeInfo.getChrLen(self._genome, self._chr), \
                              collector.getValDataType(), collector.getValDim(), \
                              collector.getEgdeWeightDataType(), collector.getEgdeWeightDim(), \
                              collector.getMaxNumEdges(self._chr, self._allowOverlaps), \
                              collector.getMaxStrLens(self._chr, self._allowOverlaps))
        
        writeFunc = dir.writeRawSlice if self._geSource.isSliceSource() else dir.writeElement
        
        for ge in self._geSource:
            writeFunc(ge)
        
        collector.appendPreProcessedChr(self._allowOverlaps, self._chr)
        
        dir.close()

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
 def assertChrElCounts(self, trackName, chrElCountDict, allowOverlaps, customBins):
     for chr in chrElCountDict.keys():
         if chr in customBins:
             region = customBins[chr]
         else:
             region = GenomeRegion(self.GENOME, chr, 0, GenomeInfo.getChrLen(self.GENOME, chr))
         tv = self._getTrackView(trackName, region, allowOverlaps)
         self.assertEquals(chrElCountDict[chr], len([x for x in tv]))

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
 def _removeBoundingRegionTuplesIfFullChrsAndNotFixedGapSize(self):
     if self.getFixedGapSize() == 0 and not self._reprIsDense:
         # If only full chromosomes
         if all(brt.region.chr in GenomeInfo.getExtendedChrList(self._genome) and \
                 brt.region.start == 0 and \
                  brt.region.end == GenomeInfo.getChrLen(self._genome, brt.region.chr) \
                   for brt in self._boundingRegionTuples):
             self._boundingRegionTuples = []

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
 def createNmerChains(self, n):
     for chr in GenomeInfo.getChrList(self._genome):
         print 'Creating chains of nmers of length ', n, ' for chromosome ', chr
         chrLen = GenomeInfo.getChrLen(self._genome,chr)
         chrReg = GenomeRegion( self._genome, chr, 0, chrLen )
         seqTV = PlainTrack( GenomeInfo.getSequenceTrackName(self._genome) ).getTrackView(chrReg)
         
         #nmersAsInts = NmerAsIntSlidingWindow(n, FuncValTvWrapper(seqTV))
         nmersAsInts = NmerAsIntSlidingWindow(n, seqTV.valsAsNumpyArray())
         SameValueIndexChainsFactory.generate( nmersAsInts, chrLen, 4**n, self._createPath(n), chr )

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
    def __iter__(self):
        chr = self.chr
        trackName1, trackName2, w1, w2, genome = self.trackName1, self.trackName2, self.w1, self.w2, self.genome
        
        region = GenomeRegion(genome, chr, 0, GenomeInfo.getChrLen(genome, chr) )

        track1 = PlainTrack(trackName1)
        tv1 = track1.getTrackView(region)
        vals1 = tv1.valsAsNumpyArray()
        
        track2 = PlainTrack(trackName2)
        tv2 = track2.getTrackView(region)
        vals2 = tv2.valsAsNumpyArray()
        
        for i in xrange(len(vals1)):
            yield w1*vals1[i] + w2*vals2[i]

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
    def createBoundingRegionShelve(genome, trackName, allowOverlaps):
        collector = TrackInfoDataCollector(genome, trackName)
        geChrList = collector.getPreProcessedChrs(allowOverlaps)

        boundingRegionTuples = [x for x in collector.getBoundingRegionTuples(allowOverlaps) if x.region.chr is not None]
        
        if len(boundingRegionTuples) == 0:
            boundingRegionTuples = [BoundingRegionTuple( \
                                     GenomeRegion(chr=chr, start=0, end=GenomeInfo.getChrLen(genome, chr)), \
                                     collector.getNumElements(chr, allowOverlaps) ) \
                                    for chr in geChrList]
        brShelve = BoundingRegionShelve(genome, trackName, allowOverlaps)
        brShelve.storeBoundingRegions(boundingRegionTuples, geChrList, not collector.getTrackFormat().reprIsDense())
        
        boundingRegionChrs = set([br.region.chr for br in boundingRegionTuples])
        for chr in boundingRegionChrs | set(geChrList):
            if brShelve.getTotalElementCount(chr) != collector.getNumElements(chr, allowOverlaps):
                raise ShouldNotOccurError("Error: The total element count for all bounding regions of chromosome '%s' is not equal to the number of genome elements of that chromosome. %s != %s" % \
                                          (chr, brShelve.getTotalElementCount(chr), collector.getNumElements(chr, allowOverlaps)) )

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
 def _createNmerTrack(self, nmerList, lowerOrder=None):
     nmerLengths = list(set([len(nmer) for nmer in nmerList]))
     assert len(nmerLengths)==1
     
     chainOrder = lowerOrder if lowerOrder is not None else nmerLengths[0]
     
     regionList = [GenomeRegion(self._genome, chr, 0, GenomeInfo.getChrLen(self._genome, chr) ) for chr in GenomeInfo.getChrList(self._genome)]
     
     for region in regionList:
         print '|',
         
         chains = SameValueIndexChainsFactory.load(self._createPath(chainOrder), region.chr)
         
         for nmer in nmerList:
             if len(nmerList) > 1:
                 print '.',
             
             if lowerOrder is not None:
                 nmerPrefix = nmer[0:chainOrder]
                 rawIndexGenerator = chains.getIndexGenerator(NmerTools.nmerAsInt(nmerPrefix))             
                 indexGenerator = LowerOrderChainWrapper(rawIndexGenerator, nmerPrefix, nmer, self._genome, region.chr)
             else:
                 indexGenerator = chains.getIndexGenerator(NmerTools.nmerAsInt(nmer)) 
     
             #print 'Length of lower order chain: %i and %i' % (sum(1 for x in indexGenerator), sum(1 for x in indexGenerator))
             #print 'Length of wrapped chain: %i and %i' % (sum(1 for x in wrappedIndexGenerator), sum(1 for x in wrappedIndexGenerator))            
             
             PreProcessCustomTrackJob(self._genome, self._createTrackName(nmer), [region], \
                                      self._getNmerGeSourceForChr, finalize=False, preProcess=True, \
                                      indexGenerator=indexGenerator).process()
                 
     for nmer in nmerList:
         try:
             PreProcessCustomTrackJob(self._genome, self._createTrackName(nmer), regionList, \
                                      self._getNmerGeSourceForChr, preProcess=False, finalize=True, \
                                      indexGenerator=[0]).process()
         except EmptyGESourceError:
             PreProcessCustomTrackJob(self._genome, self._createTrackName(nmer), [GenomeRegion(self._genome, regionList[0].chr, -1, 0)], \
                                      self._getNmerGeSourceForChr, preProcess=True, finalize=True, \
                                      indexGenerator=[-1]).process()
     
     return

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
    def nextBin(self):
        #start = self.start
        #for chr in self.chromosomes:
        #    if self.genome:
        #        chrLen = GenomeInfo.getChrLen(self.genome, chr)
        #    else:
        #        chrLen = self.end
        #        assert chrLen is not None
        #    
        #    if self.end is None:
        #        chrEnd = chrLen
        #    else:
        #        chrEnd = min(self.end, chrLen)
        #    #chrLen = 3100000
        #    
        #    while (start < chrEnd):
        #        if self.binLen is not None:
        #            end = min(start+self.binLen, chrEnd)
        #        else:
        #            end = chrEnd
        #        #print 'YIELDING: ',start, end, chrEnd
        #        yield GenomeRegion(self.genome, chr, start, end)
        #        if self.binLen is not None:
        #            start += self.binLen
        #        else:
        #            start = chrLen
        #
        #    #in case of more chromosomes, reset start:
        #    start = 0
        for region in self._userBinSource:
            start = region.start if region.start is not None else 0

            chrLen = GenomeInfo.getChrLen(region.genome, region.chr) if region.genome is not None else None
            regEnd = min([x for x in [region.end, chrLen] if x is not None])
            
            if self._binLen is None:
                yield GenomeRegion(region.genome, region.chr, start, regEnd)
            else:
                while start < regEnd:
                    end = min(start + self._binLen, regEnd)
                    yield GenomeRegion(region.genome, region.chr, start, end)
                    start += self._binLen

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
 def execute(cls, choices, galaxyFn=None, username=''):
     from quick.application.ExternalTrackManager import ExternalTrackManager
     
     genome = choices[0]
     preProcTN1 = ExternalTrackManager.getPreProcessedTrackFromGalaxyTN(genome, choices[2].split(':')) if choices[1] == 'History' else choices[2].split(':')
     chrSizeDict =  dict([ ( chrom, GenomeInfo.getChrLen(genome, chrom)) for chrom in GenomeInfo.getChrList(genome)])
     
     
     trackType = choices[3].split(':')[1]
     fnSource = ExternalTrackManager.extractFnFromGalaxyTN(choices[3].split(':'))
     
     if trackType in ['marked.bed', 'category.bed', 'bed']:
         geSource = GenomeElementSorter(BedGenomeElementSource(fnSource, genome=genome)).__iter__()
         
     elif trackType == 'gtrack':
         geSource = GenomeElementSorter(GtrackGenomeElementSource(fnSource, genome=genome)).__iter__()
         #headLinesStr = geSource.getHeaderLines().replace('##','\n##')
     else:
         raise InvalidFormatError('The Binning must be of the following formats: gtrack, marked.bed, category.bed ,bed ...')
         
         
     cls.PrintResultToHistItem( galaxyFn, geSource, preProcTN1, genome, username)

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
 def execute(cls, choices, galaxyFn=None, username=''):
     outputFile =  open(galaxyFn, 'w')
     genome = choices[0]
     histItem = choices[2]
     trackItem = choices[3]
     chromRegsPath = GenomeInfo.getChrRegsFn(genome)
     
     chrSizeDict =  dict([ ( chrom, GenomeInfo.getChrLen(genome, chrom)) for chrom in GenomeInfo.getChrList(genome)])
     geSource = headLinesStr = None
     if choices[1] == 'History':
         
         trackType = choices[2].split(':')[1]
         username = ''.join([chr(random.randint(97,122)) for i in range(6)]) 
         tempFn = createCollectedPath(genome, [], username+'_'.join([str(v) for v in time.localtime()[:6]])+'.'+trackType)
         fnSource = ExternalTrackManager.extractFnFromGalaxyTN(choices[2].split(':'))
         open(tempFn,'w').write(open(fnSource,'r').read())
         
         
         if trackType in ['marked.bed', 'category.bed', 'bed']:
             geSource = GenomeElementSorter(BedGenomeElementSource(tempFn, genome=genome)).__iter__()
         
         elif trackType == 'gtrack':
             geSource = GenomeElementSorter(GtrackGenomeElementSource(tempFn, genome=genome)).__iter__()
             headLinesStr = geSource.getHeaderLines().replace('##','\n##')
         
         cls.WriteExpandedElementsToFile(geSource, chrSizeDict, outputFile, headLinesStr, writeHeaderFlag=True)
         os.remove(tempFn)
     
     else:
         writeHeaderFlag = True
         for chrom in GenomeInfo.getChrList(genome):
             gRegion = GenomeRegion(genome, chrom, 0, chrSizeDict[chrom])
             plTrack = PlainTrack(trackItem.split(':'))
             geSource = GenomeElementTvWrapper(plTrack.getTrackView(gRegion)).__iter__()
             cls.WriteExpandedElementsToFile(geSource, chrSizeDict, outputFile, headLinesStr, writeHeaderFlag)
             writeHeaderFlag = False    
     outputFile.close()

# 需要导入模块: from quick.util.GenomeInfo import GenomeInfo [as 别名]
# 或者: from quick.util.GenomeInfo.GenomeInfo import getChrLen [as 别名]
 def _createTrackCommon(cls, genome, inTrackName, outTrackName, windowSize, func, username, chrList):
     regionList = [GenomeRegion(genome, chr, 0, GenomeInfo.getChrLen(genome, chr) ) for chr in chrList]
     PreProcessCustomTrackJob(genome, outTrackName, regionList, cls._getGeSourceForRegion, \
                              username=username, inTrackName=inTrackName, windowSize=windowSize, func=func).process()