예제 #1
0
        public void Execute()
        {
            var bamAlignment      = new BamAlignment();
            int?chrFilterRefIndex = null;

            if (_chrFilter != null)
            {
                chrFilterRefIndex = _bamReader.GetReferenceIndex(_chrFilter);
            }

            while (true)
            {
                if (_bufferSize != null && _alignmentBuffer.Count > _bufferSize)
                {
                    FlushToBam();
                }


                var hasMoreReads = _bamReader.GetNextAlignment(ref bamAlignment, false);
                if (!hasMoreReads)
                {
                    break;
                }

                if (chrFilterRefIndex != null)
                {
                    if (bamAlignment.RefID < chrFilterRefIndex.Value)
                    {
                        continue;
                    }
                    if (bamAlignment.RefID > chrFilterRefIndex.Value)
                    {
                        OnLog("Ending BAM reading for " + _chrFilter + ".");
                        break;
                    }
                }

                if (_getUnpaired && _filter.ReachedFlushingCheckpoint(bamAlignment))
                {
                    var unpaired = _filter.GetFlushableUnpairedReads();
                    _alignmentBuffer.AddRange(unpaired);
                }

                var filteredReadPair = _filter.TryPair(bamAlignment);
                if (filteredReadPair != null)
                {
                    _alignmentBuffer.AddRange(_pairHandler.ExtractReads(filteredReadPair));
                }
            }

            if (_getUnpaired)
            {
                var unpaired = _filter.GetFlushableUnpairedReads();
                _alignmentBuffer.AddRange(unpaired);
            }
            FlushToBam();
        }
예제 #2
0
        public void Execute()
        {
            var bamAlignment     = new BamAlignment();
            var bamWriterHandles = _bamWriter.GenerateHandles();

            int?chrFilterRefIndex = null;

            if (_chrFilter != null)
            {
                chrFilterRefIndex = _bamReader.GetReferenceIndex(_chrFilter);
            }

            const int       READ_BUFFER_SIZE = 64;
            List <ReadPair> readPairBuffer   = new List <ReadPair>(READ_BUFFER_SIZE);

            while (true)
            {
                var hasMoreReads = _bamReader.GetNextAlignment(ref bamAlignment, false);
                if (!hasMoreReads)
                {
                    break;
                }

                if (chrFilterRefIndex != null)
                {
                    if (bamAlignment.RefID < chrFilterRefIndex.Value)
                    {
                        continue;
                    }
                    if (bamAlignment.RefID > chrFilterRefIndex.Value)
                    {
                        Logger.WriteToLog("Ending BAM reading for " + _chrFilter + ".");
                        break;
                    }
                }

                if (_getUnpaired && _filter.ReachedFlushingCheckpoint(bamAlignment))
                {
                    ExecuteTask(new FlushableUnpairedReadsTask(_filter.GetFlushableUnpairedReads(), bamWriterHandles));
                }

                var filteredReadPair = _filter.TryPair(bamAlignment);
                if (filteredReadPair != null)
                {
                    readPairBuffer.Add(filteredReadPair);
                    if (readPairBuffer.Count >= READ_BUFFER_SIZE - 1)
                    {
                        ExecuteTask(new ExtractReadsTask(_pairHandlers, readPairBuffer, bamWriterHandles, _filter));

                        readPairBuffer = new List <ReadPair>(READ_BUFFER_SIZE);
                    }
                }
            }

            if (readPairBuffer.Count > 0)
            {
                ExecuteTask(new ExtractReadsTask(_pairHandlers, readPairBuffer, bamWriterHandles, _filter));
            }

            if (_getUnpaired)
            {
                ExecuteTask(new FlushableUnpairedReadsTask(_filter.GetFlushableUnpairedReads(), bamWriterHandles));
            }

            WaitForFinishTask.WaitUntilZeroTasks();
        }
        public ReadPair GetNextEntryUntilNull()
        {
            var bamAlignment = new BamAlignment();

            while (!_hasPassedChrom)
            {
                bool hasMoreReads;

                hasMoreReads = _bamReader.GetNextAlignment(ref bamAlignment, false);

                if (!hasMoreReads || _applyChrFilter && bamAlignment.RefID > _refId)
                {
                    FlushUnpaired();

                    if (_applyChrFilter && bamAlignment.RefID > _refId)
                    {
                        _hasPassedChrom = true;
                    }
                    break;
                }

                if (_applyChrFilter && bamAlignment.RefID < _refId)
                {
                    AddStatus(TooLow);
                    continue;
                }

                if (bamAlignment.IsDuplicate() && _skipAndRemoveDuplicates)
                {
                    AddStatus(Duplicate);
                    continue;
                }

                // TODO did we want to handle secondary/supplementaries differently?
                //if (bamAlignment.IsSecondary() || !bamAlignment.IsPrimaryAlignment())
                //{
                //    continue;
                //}

                if (ShouldSkipRead(bamAlignment))
                {
                    continue;
                }

                var status = SingleReadStatus(bamAlignment);

                if (status != PairStatus.Unknown)
                {
                    AddStatus(WontPair);
                    return(new ReadPair(bamAlignment)
                    {
                        PairStatus = status
                    });
                }

                var filteredReadPair = _filter.TryPair(bamAlignment, status);

                if (filteredReadPair != null)
                {
                    if (filteredReadPair.PairStatus != PairStatus.OffTarget)
                    {
                        filteredReadPair.PairStatus = PairStatus.Paired;
                    }
                    return(filteredReadPair);
                }
            }

            while (true)
            {
                if (_unpaired == null || !_unpaired.Any())
                {
                    break;
                }

                return(_unpaired.Dequeue());
            }


            return(null);
        }