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)));
}
