Exemple #1
0
        private void ProcessVariant(IAlleleSource source, CalledAllele variant)
        {
            // determine metrics
            _coverageCalculator.Compute(variant, source);

            if (variant.AlleleSupport > 0)
            {
                if (_config.NoiseModel == NoiseModel.Window)
                {
                    VariantQualityCalculator.Compute(variant, _config.MaxVariantQscore, (int)MathOperations.PtoQ(variant.SumOfBaseQuality / variant.TotalCoverage));
                }
                else
                {
                    VariantQualityCalculator.Compute(variant, _config.MaxVariantQscore, _config.EstimatedBaseCallQuality);
                }

                StrandBiasCalculator.Compute(variant, variant.SupportByDirection, _config.EstimatedBaseCallQuality,
                                             _config.StrandBiasFilterThreshold, _config.StrandBiasModel);
            }

            // set genotype, filter, etc
            AlleleProcessor.Process(variant, _config.MinFrequency, _config.LowDepthFilter,
                                    _config.VariantQscoreFilterThreshold, _config.FilterSingleStrandVariants, _config.VariantFreqFilter, _config.LowGTqFilter, _config.IndelRepeatFilter,
                                    _config.RMxNFilterSettings, _config.ChrReference, source.ExpectStitchedReads);
        }
        private StrandBiasResults ExecuteTest(Tuple <double, int> forwardStats, Tuple <double, int> reverseStats, Tuple <double, int> stitchedStats,
                                              int estimatedBaseCallQuality = 20, float threshold = 0.5f, StrandBiasModel model = StrandBiasModel.Poisson)
        {
            var origForwardSupport  = (int)(forwardStats.Item1 * forwardStats.Item2);
            var origReverseSupport  = (int)(reverseStats.Item1 * reverseStats.Item2);
            var origStitchedSupport = (int)(stitchedStats.Item1 * stitchedStats.Item2);
            var support             = new int[]
            {
                origForwardSupport,
                origReverseSupport,
                origStitchedSupport,
            };

            var variant = new CalledVariant(AlleleCategory.Snv)
            {
                TotalCoverageByDirection = new int[]
                {
                    forwardStats.Item2, reverseStats.Item2, stitchedStats.Item2
                }
            };

            StrandBiasCalculator.Compute(variant, support, estimatedBaseCallQuality, threshold, model);
            Assert.Equal(origForwardSupport + ((float)origStitchedSupport / 2), variant.StrandBiasResults.ForwardStats.Support);
            Assert.Equal(origReverseSupport + ((float)origStitchedSupport / 2), variant.StrandBiasResults.ReverseStats.Support);
            return(variant.StrandBiasResults);
        }
Exemple #3
0
        private void ProcessVariant(IStateManager source, BaseCalledAllele variant)
        {
            // determine metrics
            CoverageCalculator.Compute(variant, source);
            QualityCalculator.Compute(variant, _config.MaxVariantQscore, _config.EstimatedBaseCallQuality);
            StrandBiasCalculator.Compute(variant, variant.SupportByDirection, _config.EstimatedBaseCallQuality,
                                         _config.StrandBiasFilterThreshold, _config.StrandBiasModel);

            // set genotype, filter, etc
            AlleleProcessor.Process(variant, _config.GenotypeModel, _config.MinFrequency, _config.MinCoverage,
                                    _config.VariantQscoreFilterThreshold, _config.FilterSingleStrandVariants);
        }