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