public void Compute() { // Based on Tamsen's original PValue test, just extended to our Compute method List <int[]> SampleValues_ExpectedQScore = new List <int[]>() //coverage,var calls} { new int[] { 100, 0, 0 }, new int[] { 100, 1, 2 }, new int[] { 100, 5, 24 }, new int[] { 200, 10, 43 }, new int[] { 500, 25, 98 }, new int[] { 5000, 250, 100 }, }; foreach (int[] item in SampleValues_ExpectedQScore) { var variant = new CalledVariant(AlleleCategory.Snv) { Coordinate = 1, Reference = "A", Alternate = "T", TotalCoverage = item[0], AlleleSupport = item[1], }; QualityCalculator.Compute(variant, 100, 20); Assert.Equal(item[2], variant.Qscore); } }
static void Main(string[] args) { System.Console.WriteLine("OMGHAI!"); Items = new List<Item> { new Item {Name = "+5 Dexterity Vest", SellIn = 10, Quality = 20}, new Item {Name = "Aged Brie", SellIn = 2, Quality = 0}, new Item {Name = "Elixir of the Mongoose", SellIn = 5, Quality = 7}, new Item {Name = "Sulfuras, Hand of Ragnaros", SellIn = 0, Quality = 80}, new Item { Name = "Backstage passes to a TAFKAL80ETC concert", SellIn = 15, Quality = 20 }, new Item {Name = "Conjured Mana Cake", SellIn = 3, Quality = 6} }; var qualityCalculator = new QualityCalculator( Items ); qualityCalculator.UpdateQuality(); System.Console.ReadKey(); }
public void AssignPValue() { var callCount = 1; double pValue = QualityCalculator.AssignPValue(callCount, 100, 20); Assert.Equal(0.6321, pValue, 4); //If observed call count is 0, return 1 callCount = 0; pValue = QualityCalculator.AssignPValue(callCount, 100, 20); Assert.Equal(1, pValue, 4); }
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); }
public void AssignPoissonQScore() { //If rounded qScore is above maxQScore, should return maxQScore var coverage = 500; var varSupport = 25; var estQuality = 20; var expectedActualQValue = 98; var maxQValue = expectedActualQValue + 1; maxQValue = 1000; double finalQValue = QualityCalculator.AssignPoissonQScore(varSupport, coverage, estQuality, maxQValue); Assert.Equal(expectedActualQValue, finalQValue); maxQValue = expectedActualQValue - 1; finalQValue = QualityCalculator.AssignPoissonQScore(varSupport, coverage, estQuality, maxQValue); Assert.Equal(maxQValue, finalQValue); }
/// <summary> /// Retrieve all applicable values from the DHT. /// </summary> /// <param name="key">The key of the value to retrieve.</param> /// <returns>All the list of resources found on network, ordered by semantic affinity</returns> public IList <KademliaResource> GetAll(string key) { IList <KademliaResource> found = dhtNode.Get(key); if (found.Count > 0) { return(found.AsParallel().OrderByDescending( d => QualityCalculator.calculateQualityCoefficient( key, new string[3] { d.Tag.Album, d.Tag.Artist, d.Tag.Title }, 0, 0, d.Tag.Bitrate, d.Tag.Channels, d.Tag.SampleRate) ).ToList()); } else { return(found); } }
/// <summary> /// Retrieve a value from the DHT. /// </summary> /// <param name="key">The key of the value to retrieve.</param> /// <returns>the best semantically matching value stored for the key, or null if no values are found</returns> public KademliaResource Get(string key) { IList <KademliaResource> found = dhtNode.Get(key); if (found.Count > 0) { IList <KademliaResource> ordered = found.AsParallel().OrderByDescending( d => QualityCalculator.calculateQualityCoefficient( key, new string[3] { d.Tag.Album, d.Tag.Artist, d.Tag.Title }, 0, 0, d.Tag.Bitrate, d.Tag.Channels, d.Tag.SampleRate) ).ToList(); return(ordered[0]); // An arbitrary value } else { return(null); // Nothing there } }
public void CallSomaticVariants_AssignPValue() { List <int[]> SampleValues = new List <int[]>() //coverage,var calls} { new int[] { 100, 0 }, new int[] { 100, 1 }, new int[] { 100, 5 }, new int[] { 200, 10 }, new int[] { 500, 25 }, new int[] { 5000, 250 }, }; List <double[]> ReturnedValues = new List <double[]>(); { }//p,Q foreach (int[] item in SampleValues) { double pValue = QualityCalculator.AssignPValue(item[1], item[0], 20); double Qscore = MathOperations.PtoQ(pValue); double FinalQValue = QualityCalculator.AssignPoissonQScore(item[1], item[0], 20, 100); double[] Result = new double[] { pValue, Qscore, FinalQValue }; ReturnedValues.Add(Result); } Assert.Equal(ReturnedValues[0][0], 1, 4); Assert.Equal(ReturnedValues[0][2], 0, 4); Assert.Equal(ReturnedValues[1][0], 0.6321, 4); Assert.Equal(ReturnedValues[1][2], 2, 4); Assert.Equal(ReturnedValues[2][0], 0.003659, 4); Assert.Equal(ReturnedValues[2][2], 24, 4); Assert.Equal(ReturnedValues[3][0], 4.65 * Math.Pow(10, -5), 5); Assert.Equal(ReturnedValues[3][2], 43, 4); Assert.Equal(ReturnedValues[4][0], 1.599 * Math.Pow(10, -10), 10); Assert.Equal(ReturnedValues[4][2], 98, 4); Assert.Equal(ReturnedValues[5][0], 0.0, 10); Assert.Equal(ReturnedValues[5][2], 100, 4); }
public void EvaluateVariants() { var config = new VariantCallerConfig { MaxVariantQscore = 100, EstimatedBaseCallQuality = 20 }; var variantCaller = new AlleleCaller(config); var highCoverageCoordinate = 123; var lowCoverageCoordinate = 456; var passingVariant = new CandidateAllele("chr1", highCoverageCoordinate, "A", "T", AlleleCategory.Snv) { SupportByDirection = new [] { 500, 0, 0 } // Freq is 500/1500, q is 100 }; var passingVariant2 = new CandidateAllele("chr1", highCoverageCoordinate, "A", "C", AlleleCategory.Snv) { SupportByDirection = new[] { 500, 0, 0 } // Freq is 500/1500, q is 100 }; var lowFreqVariant = new CandidateAllele("chr2", highCoverageCoordinate, "A", "T", AlleleCategory.Snv) { SupportByDirection = new[] { 1, 0, 0 } // Freq is 1/1500, q is 0 }; var lowCoverageVariant = new CandidateAllele("chr3", lowCoverageCoordinate, "A", "T", AlleleCategory.Snv) { SupportByDirection = new[] { 10, 0, 0 } // Freq is 10/15, q is 100 }; var lowqVariant = new CandidateAllele("chr4", highCoverageCoordinate, "A", "T", AlleleCategory.Snv) { SupportByDirection = new[] { 40, 0, 0 } // Freq is 40/1500, q is 72 }; var passingReferenceHigh = new CandidateAllele("chr1", highCoverageCoordinate, "A", "A", AlleleCategory.Reference) { SupportByDirection = new[] { 500, 0, 0 } // Freq is 500/1500, q is 100 }; var passingReferenceLow = new CandidateAllele("chr3", lowCoverageCoordinate, "A", "A", AlleleCategory.Reference) { SupportByDirection = new[] { 10, 0, 0 } // Freq is 10/15, q is 100 }; var candidateVariants = new List <CandidateAllele> { passingVariant }; //Variants should be correctly mapped var mockAlleleCountSource = MockStateManager(highCoverageCoordinate, lowCoverageCoordinate).Object; var calledVariants = variantCaller.Call(new CandidateBatch(candidateVariants), mockAlleleCountSource); var calledVariant = calledVariants.First(); Assert.Equal(passingVariant.Alternate, calledVariant.Alternate); Assert.Equal(passingVariant.Reference, calledVariant.Reference); Assert.Equal(passingVariant.Chromosome, calledVariant.Chromosome); Assert.Equal(passingVariant.Coordinate, calledVariant.Coordinate); Assert.Equal(passingVariant.Support, calledVariant.AlleleSupport); Assert.True(calledVariant is CalledVariant); Assert.True(((CalledVariant)calledVariant).Type == AlleleCategory.Snv); //After the Calculator steps are performed, variants that don't meet //our requirements to be callable should drop out //High coverage requirement - lowCoverageVariant should drop out. config.MinCoverage = (HighCoverageMultiplier * NumAlleles * NumDirections) - 1; config.IncludeReferenceCalls = false; config.MinVariantQscore = 0; config.MinFrequency = 0; variantCaller = new AlleleCaller(config); candidateVariants = new List <CandidateAllele> { passingVariant, lowFreqVariant, lowCoverageVariant }; calledVariants = variantCaller.Call(new CandidateBatch(candidateVariants), mockAlleleCountSource); Assert.Equal(2, calledVariants.Count()); Assert.True(calledVariants.Any(v => MatchVariants(v, passingVariant))); Assert.True(calledVariants.Any(v => MatchVariants(v, lowFreqVariant))); Assert.False(calledVariants.Any(v => MatchVariants(v, lowCoverageVariant))); //High coverage but allow reference calls = nothing should drop out config.IncludeReferenceCalls = true; variantCaller = new AlleleCaller(config); candidateVariants = new List <CandidateAllele> { passingVariant, lowFreqVariant, lowCoverageVariant }; calledVariants = variantCaller.Call(new CandidateBatch(candidateVariants), mockAlleleCountSource); foreach (var cvar in calledVariants) { Console.WriteLine(cvar.Qscore); } Assert.Equal(3, calledVariants.Count()); //High frequency requirement - low frequency variant should drop out config.MinCoverage = 0; config.IncludeReferenceCalls = false; config.MinVariantQscore = 0; config.MinFrequency = ((float)lowCoverageVariant.Support + 1) / (HighCoverageMultiplier * NumAlleles * NumDirections); calledVariants = variantCaller.Call(new CandidateBatch(candidateVariants), mockAlleleCountSource); Assert.Equal(2, calledVariants.Count()); Assert.True(calledVariants.Any(v => MatchVariants(v, passingVariant))); Assert.False(calledVariants.Any(v => MatchVariants(v, lowFreqVariant))); Assert.True(calledVariants.Any(v => MatchVariants(v, lowCoverageVariant))); //High q score requirement - low frequency variant should drop out config.MinCoverage = 0; config.IncludeReferenceCalls = false; config.MinVariantQscore = 0; config.MinFrequency = 0; config.MinVariantQscore = QualityCalculator.AssignPoissonQScore(lowqVariant.Support, (HighCoverageMultiplier * Constants.NumCovContributingAlleleTypes * Constants.NumDirectionTypes), config.EstimatedBaseCallQuality, config.MaxVariantQscore) + 1; candidateVariants = new List <CandidateAllele> { passingVariant, passingVariant2, lowFreqVariant, lowCoverageVariant, lowqVariant }; calledVariants = variantCaller.Call(new CandidateBatch(candidateVariants), mockAlleleCountSource); Assert.Equal(3, calledVariants.Count()); Assert.True(calledVariants.Any(v => MatchVariants(v, passingVariant))); Assert.True(calledVariants.Any(v => MatchVariants(v, passingVariant2))); Assert.False(calledVariants.Any(v => MatchVariants(v, lowFreqVariant))); Assert.True(calledVariants.Any(v => MatchVariants(v, lowCoverageVariant))); Assert.False(calledVariants.Any(v => MatchVariants(v, lowqVariant))); // reference calls included candidateVariants = new List <CandidateAllele> { passingReferenceHigh, passingReferenceLow }; calledVariants = variantCaller.Call(new CandidateBatch(candidateVariants), mockAlleleCountSource); Assert.Equal(2, calledVariants.Count()); Assert.True(calledVariants.Any(v => MatchVariants(v, passingReferenceHigh))); Assert.True(calledVariants.Any(v => MatchVariants(v, passingReferenceLow))); // reference calls only included if no passing variant candidateVariants = new List <CandidateAllele> { passingReferenceHigh, passingReferenceLow, passingVariant, passingVariant2, lowFreqVariant, lowCoverageVariant, lowqVariant }; calledVariants = variantCaller.Call(new CandidateBatch(candidateVariants), mockAlleleCountSource); Assert.Equal(3, calledVariants.Count()); Assert.False(calledVariants.Any(v => MatchVariants(v, passingReferenceHigh))); Assert.False(calledVariants.Any(v => MatchVariants(v, passingReferenceLow))); Assert.True(calledVariants.Any(v => MatchVariants(v, passingVariant))); Assert.True(calledVariants.Any(v => MatchVariants(v, passingVariant2))); Assert.False(calledVariants.Any(v => MatchVariants(v, lowFreqVariant))); Assert.True(calledVariants.Any(v => MatchVariants(v, lowCoverageVariant))); Assert.False(calledVariants.Any(v => MatchVariants(v, lowqVariant))); // reference calls only included if no passing variant (lowCoverageVariant fails) candidateVariants = new List <CandidateAllele> { passingReferenceLow, lowCoverageVariant, }; config.IncludeReferenceCalls = false; config.MinCoverage = (HighCoverageMultiplier * NumAlleles * NumDirections) - 1; variantCaller = new AlleleCaller(config); calledVariants = variantCaller.Call(new CandidateBatch(candidateVariants), mockAlleleCountSource); Assert.Equal(1, calledVariants.Count()); Assert.True(calledVariants.Any(v => MatchVariants(v, passingReferenceLow))); Assert.False(calledVariants.Any(v => MatchVariants(v, lowCoverageVariant))); // candidates outside of intervals are trimmed off config.MinCoverage = 0; config.MinVariantQscore = 0; config.MinFrequency = 0; variantCaller = new AlleleCaller(config, new ChrIntervalSet(new List <Region>() { new Region(highCoverageCoordinate, lowCoverageCoordinate) }, "chr1")); candidateVariants = new List <CandidateAllele> { passingVariant, lowFreqVariant, lowCoverageVariant }; calledVariants = variantCaller.Call(new CandidateBatch(candidateVariants), mockAlleleCountSource); Assert.Equal(3, calledVariants.Count()); Assert.True(calledVariants.Any(v => MatchVariants(v, passingVariant))); Assert.True(calledVariants.Any(v => MatchVariants(v, lowFreqVariant))); Assert.True(calledVariants.Any(v => MatchVariants(v, lowCoverageVariant))); variantCaller = new AlleleCaller(config, new ChrIntervalSet(new List <Region>() { new Region(highCoverageCoordinate, highCoverageCoordinate) }, "chr1")); calledVariants = variantCaller.Call(new CandidateBatch(candidateVariants), mockAlleleCountSource); Assert.Equal(2, calledVariants.Count()); Assert.True(calledVariants.Any(v => MatchVariants(v, passingVariant))); Assert.True(calledVariants.Any(v => MatchVariants(v, lowFreqVariant))); Assert.False(calledVariants.Any(v => MatchVariants(v, lowCoverageVariant))); }