예제 #1
0
        private void ComputeCoverageTest(BaseCalledAllele variant, List <AlleleCount> stagedCounts,
                                         int[] expectedCoverageByDirection, bool checkAux = true, int alleleSupport = 5, int expectedSnvRef = 0, int takenRefSupport = 0)
        {
            variant.AlleleSupport = alleleSupport;

            var mockStateManager = CreateMockStateManager(stagedCounts, takenRefSupport);

            var expectedCoverage = expectedCoverageByDirection.Sum();

            CoverageCalculator.Compute(variant, mockStateManager);

            Assert.Equal(expectedCoverage, variant.TotalCoverage);

            for (var i = 0; i < expectedCoverageByDirection.Length; i++)
            {
                Assert.Equal(expectedCoverageByDirection[i], variant.TotalCoverageByDirection[i]);
            }

            if (checkAux)
            {
                //"Reference" Support should be the coverage less the variant support, if we don't have an SNV
                if (variant is CalledVariant && variant.Type != AlleleCategory.Snv)
                {
                    Assert.Equal(expectedCoverage - variant.AlleleSupport, ((CalledVariant)variant).ReferenceSupport);
                }
                else
                {
                    Assert.Equal(expectedSnvRef, ((CalledVariant)variant).ReferenceSupport);
                }

                //Frequency should be support/coverage
                Assert.Equal((float)variant.AlleleSupport / expectedCoverage, variant.Frequency);
            }
        }
예제 #2
0
        public static ISomaticVariantCaller CreateMockVariantCaller(VcfFileWriter vcfWriter, ApplicationOptions options, ChrReference chrRef, MockAlignmentExtractor mockAlignmentExtractor, IStrandBiasFileWriter biasFileWriter = null, string intervalFilePath = null)
        {
            var config = new AlignmentSourceConfig
            {
                MinimumMapQuality  = options.MinimumMapQuality,
                OnlyUseProperPairs = options.OnlyUseProperPairs,
            };


            //var mateFinder = options.StitchReads ? new AlignmentMateFinder() : null;
            AlignmentMateFinder mateFinder = null;
            var alignmentSource            = new AlignmentSource(mockAlignmentExtractor, mateFinder, config);
            var variantFinder      = new CandidateVariantFinder(options.MinimumBaseCallQuality, options.MaxSizeMNV, options.MaxGapBetweenMNV, options.CallMNVs);
            var coverageCalculator = new CoverageCalculator();

            var alleleCaller = new AlleleCaller(new VariantCallerConfig
            {
                IncludeReferenceCalls        = options.OutputgVCFFiles,
                MinVariantQscore             = options.MinimumVariantQScore,
                MaxVariantQscore             = options.MaximumVariantQScore,
                VariantQscoreFilterThreshold = options.FilteredVariantQScore > options.MinimumVariantQScore ? options.FilteredVariantQScore : (int?)null,
                MinCoverage                = options.MinimumDepth,
                MinFrequency               = options.MinimumFrequency,
                EstimatedBaseCallQuality   = options.AppliedNoiseLevel == -1 ? options.MinimumBaseCallQuality : options.AppliedNoiseLevel,
                StrandBiasModel            = options.StrandBiasModel,
                StrandBiasFilterThreshold  = options.StrandBiasAcceptanceCriteria,
                FilterSingleStrandVariants = options.FilterOutVariantsPresentOnlyOneStrand,
                ChrReference               = chrRef
            },
                                                coverageCalculator: coverageCalculator,
                                                variantCollapser: options.Collapse ? new VariantCollapser(null, coverageCalculator) : null);

            var stateManager = new RegionStateManager(
                expectStitchedReads: mockAlignmentExtractor.SourceIsStitched,
                trackOpenEnded: options.Collapse, trackReadSummaries: options.CoverageMethod == CoverageMethod.Approximate);

            //statmanager is an allele source
            Assert.Equal(0, stateManager.GetAlleleCount(1, AlleleType.A, DirectionType.Forward));


            return(new SomaticVariantCaller(
                       alignmentSource,
                       variantFinder,
                       alleleCaller,
                       vcfWriter,
                       stateManager,
                       chrRef,
                       null,
                       biasFileWriter));
        }