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));
}
private static Dictionary <int, List <LoadTestResult> > GetCountsFromManager(RegionStateManager manager)
{
var directions = Enum.GetValues(typeof(DirectionType));
var alleles = Enum.GetValues(typeof(AlleleType));
int maxPosWeCareAbout = 12;
Dictionary <int, List <LoadTestResult> > countResults = new Dictionary <int, List <LoadTestResult> >();
for (int pos = 1; pos < maxPosWeCareAbout; pos++)
{
List <LoadTestResult> results = new List <LoadTestResult>();
countResults.Add(pos, results);
foreach (AlleleType alleleType in alleles)
{
for (int i = 0; i < directions.Length; i++)
{
int count = manager.GetAlleleCount(pos, alleleType, (DirectionType)i);
if (count != 0)
{
LoadTestResult result = new LoadTestResult()
{
Position = pos,
BaseCall = alleleType,
BaseDirection = (DirectionType)i,
Count = count
};
countResults[pos].Add(result);
}
}
}
}
return(countResults);
}
public void DoneProcessing()
{
var stateManager = new RegionStateManager();
var readLists = new List <List <Read> >
{
TestHelper.CreateTestReads(ReadTestHelper.CreateRead("chr1", "A", 1)), // 1-1000
TestHelper.CreateTestReads(ReadTestHelper.CreateRead("chr1", "A", 1001)), // 1001-2000
TestHelper.CreateTestReads(ReadTestHelper.CreateRead("chr1", "A", 2001)), // 2001-3000
TestHelper.CreateTestReads(ReadTestHelper.CreateRead("chr1", "A", 3001)), // 2001-3000
TestHelper.CreateTestReads(ReadTestHelper.CreateRead("chr1", "A", 5001)), // 5001-6000
TestHelper.CreateTestReads(ReadTestHelper.CreateRead("chr1", "A", 7001)) // 7001-8000
};
foreach (var readList in readLists)
{
foreach (var read in readList)
{
stateManager.AddAlleleCounts(read);
}
}
// blocks should all be in memory
Assert.Equal(1, stateManager.GetAlleleCount(1, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(2001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(3001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(5001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(7001, AlleleType.A, DirectionType.Forward));
stateManager.AddCandidates(new List <CandidateAllele>()
{
new CandidateAllele("chr1", 1, "T", "A", AlleleCategory.Snv),
new CandidateAllele("chr1", 3001, new string('A', 3500), "A", AlleleCategory.Deletion)
});
var batch = stateManager.GetCandidatesToProcess(1);
stateManager.DoneProcessing(batch);
Assert.Equal(1, stateManager.GetAlleleCount(1, AlleleType.A, DirectionType.Forward));
batch = stateManager.GetCandidatesToProcess(1500);
stateManager.DoneProcessing(batch);
Assert.Equal(0, stateManager.GetAlleleCount(1, AlleleType.A, DirectionType.Forward));
batch = stateManager.GetCandidatesToProcess(2001);
stateManager.DoneProcessing(batch);
Assert.Equal(0, stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(2001, AlleleType.A, DirectionType.Forward));
// blocks 1001-2000 and 2001-3000 should be cleared
batch = stateManager.GetCandidatesToProcess(5500);
stateManager.DoneProcessing(batch);
Assert.Equal(0, stateManager.GetAlleleCount(1, AlleleType.A, DirectionType.Forward));
Assert.Equal(0, stateManager.GetAlleleCount(2001, AlleleType.A, DirectionType.Forward));
//3001 block shouldn't be cleared yet because it holds a variant that extends into a further block
Assert.Equal(1, stateManager.GetAlleleCount(3001, AlleleType.A, DirectionType.Forward));
//5001 block shouldn't be cleared yet because it comes later than a held-up block
Assert.Equal(1, stateManager.GetAlleleCount(5001, AlleleType.A, DirectionType.Forward));
batch = stateManager.GetCandidatesToProcess(6500);
stateManager.DoneProcessing(batch);
//3001 block shouldn't be cleared yet because it holds a variant that extends into a further block
Assert.Equal(1, stateManager.GetAlleleCount(3001, AlleleType.A, DirectionType.Forward));
//5001 block shouldn't be cleared yet because it comes later than a held-up block
Assert.Equal(1, stateManager.GetAlleleCount(5001, AlleleType.A, DirectionType.Forward));
batch = stateManager.GetCandidatesToProcess(7001);
stateManager.DoneProcessing(batch);
Assert.Equal(0, stateManager.GetAlleleCount(3001, AlleleType.A, DirectionType.Forward));
Assert.Equal(0, stateManager.GetAlleleCount(5001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(7001, AlleleType.A, DirectionType.Forward));
batch = stateManager.GetCandidatesToProcess(8001);
stateManager.DoneProcessing(batch);
Assert.Equal(0, stateManager.GetAlleleCount(7001, AlleleType.A, DirectionType.Forward));
}
public void AddAndGetAlleleCounts_Deletions()
{
// make sure deletions get padded
int minQuality = 25;
var stateManager = new RegionStateManager(false, minQuality);
var alignmentSet = TestHelper.CreateTestReads(
ReadTestHelper.CreateRead("chr1", "TTTTTTTTT", 1001, new CigarAlignment("5M4D4M")), // forward counts for 1001 - 1013
ReadTestHelper.CreateRead("chr1", "AAAAAAAAA", 1005, new CigarAlignment("1M2D8M")), minQuality); // reverse counts for 1005 - 1115
var read1 = alignmentSet[0];
var read2 = alignmentSet[1];
for (var i = 0; i < read2.SequencedBaseDirectionMap.Length; i++)
{
read2.SequencedBaseDirectionMap[i] = DirectionType.Reverse;
}
foreach (var read in alignmentSet)
{
stateManager.AddAlleleCounts(read);
}
// check T counts
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.T, DirectionType.Forward), 0);
for (int i = 1001; i <= 1013; i++)
{
var alleleType = i >= 1006 && i <= 1009 ? AlleleType.Deletion : AlleleType.T;
Assert.Equal(stateManager.GetAlleleCount(i, alleleType, DirectionType.Forward), 1);
}
Assert.Equal(stateManager.GetAlleleCount(1014, AlleleType.T, DirectionType.Forward), 0);
// check A counts
Assert.Equal(stateManager.GetAlleleCount(1004, AlleleType.A, DirectionType.Reverse), 0);
for (int i = 1005; i <= 1015; i++)
{
var alleleType = i >= 1006 && i <= 1007 ? AlleleType.Deletion : AlleleType.A;
Assert.Equal(stateManager.GetAlleleCount(i, alleleType, DirectionType.Reverse), 1);
}
Assert.Equal(stateManager.GetAlleleCount(1116, AlleleType.A, DirectionType.Reverse), 0);
// ---------------------------------------
// Read beginning with deletion
// ---------------------------------------
var alignmentSet_frontEdge = TestHelper.CreateTestReads(
ReadTestHelper.CreateRead("chr1", "NNNNNTTTT", 1001, new CigarAlignment("5S2D4M")),
ReadTestHelper.CreateRead("chr1", "AAAAAAAAA", 1005, new CigarAlignment("9M")), minQuality);
stateManager = new RegionStateManager(false, minQuality);
var frontRead1 = alignmentSet_frontEdge[0];
var frontRead2 = alignmentSet_frontEdge[1];
foreach (var read in alignmentSet_frontEdge)
{
stateManager.AddAlleleCounts(read);
}
// check T counts
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.T, DirectionType.Forward), 0);
var lengthRef = ((Read)frontRead1).CigarData.GetReferenceSpan();
for (int i = 1001; i < 1001 + lengthRef - 1; i++)
{
var alleleType = i >= 1001 && i <= 1002 ? AlleleType.Deletion : AlleleType.T;
Assert.Equal(stateManager.GetAlleleCount(i, alleleType, DirectionType.Forward), 1);
}
Assert.Equal(stateManager.GetAlleleCount(1014, AlleleType.T, DirectionType.Forward), 0);
// ---------------------------------------
// Terminal deletions
// ---------------------------------------
var alignmentSet_tailEdge = TestHelper.CreateTestReads(
ReadTestHelper.CreateRead("chr1", "TTTTNNNNN", 1001, new CigarAlignment("4M2D5S")),
ReadTestHelper.CreateRead("chr1", "AAAAAAAAA", 1015, new CigarAlignment("9M2D")), minQuality);
var tailRead1 = alignmentSet_tailEdge[0];
var tailRead2 = alignmentSet_tailEdge[1];
stateManager = new RegionStateManager(false, minQuality);
for (var i = 0; i < tailRead2.SequencedBaseDirectionMap.Length; i++)
{
tailRead2.SequencedBaseDirectionMap[i] = DirectionType.Reverse;
}
foreach (var read in alignmentSet_tailEdge)
{
stateManager.AddAlleleCounts(read);
}
// check T counts
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.T, DirectionType.Forward), 0);
lengthRef = ((Read)tailRead1).CigarData.GetReferenceSpan();
var lastPos = 1001 + lengthRef - 1;
for (int i = 1001; i <= lastPos; i++)
{
var alleleType = i >= 1005 && i <= lastPos ? AlleleType.Deletion : AlleleType.T;
Assert.Equal(stateManager.GetAlleleCount(i, alleleType, DirectionType.Forward), 1);
}
Assert.Equal(stateManager.GetAlleleCount((int)lastPos + 1, AlleleType.Deletion, DirectionType.Forward), 0);
// check A counts
Assert.Equal(stateManager.GetAlleleCount(1014, AlleleType.A, DirectionType.Reverse), 0);
lengthRef = ((Read)tailRead2).CigarData.GetReferenceSpan();
lastPos = 1015 + lengthRef - 1;
for (int i = 1015; i <= lastPos; i++)
{
var alleleType = i >= 1024 && i <= lastPos ? AlleleType.Deletion : AlleleType.A;
Assert.Equal(stateManager.GetAlleleCount(i, alleleType, DirectionType.Reverse), 1);
}
Assert.Equal(stateManager.GetAlleleCount((int)lastPos + 1, AlleleType.Deletion, DirectionType.Reverse), 0);
}
public void AddAndGetAlleleCounts_PoorQualDeletions()
{
// make sure deletions get padded
int minQualityThreshold = 25;
int highQualityForRead = 30;
int lowQualityForRead = 20;
var stateManager = new RegionStateManager(false, minQualityThreshold);
var alignmentSet = TestHelper.CreateTestReads(
ReadTestHelper.CreateRead("chr1", "TTTTTTTTT", 1001, new CigarAlignment("5M4D4M")), highQualityForRead, // forward counts for 1001 - 1013
ReadTestHelper.CreateRead("chr1", "AAAAAAAAA", 1005, new CigarAlignment("1M2D8M")), lowQualityForRead); // reverse counts for 1005 - 1115
var read1 = alignmentSet[0];
var read2 = alignmentSet[1];
// T T T T T D D D D T T T T x x <fwd, q 30>
// x x x x A D D A A A A A A A A <rvs, q 15>
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
for (var i = 0; i < read2.SequencedBaseDirectionMap.Length; i++)
{
read2.SequencedBaseDirectionMap[i] = DirectionType.Reverse;
}
foreach (var read in alignmentSet)
{
stateManager.AddAlleleCounts(read);
}
// check fwd read counts (T's and D's)
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.T, DirectionType.Forward), 0);
for (int i = 1001; i <= 1013; i++)
{
var alleleType = i >= 1006 && i <= 1009 ? AlleleType.Deletion : AlleleType.T;
Assert.Equal(stateManager.GetAlleleCount(i, alleleType, DirectionType.Forward), 1);
}
Assert.Equal(stateManager.GetAlleleCount(1014, AlleleType.T, DirectionType.Forward), 0);
// check rev counts (A's and D's). Should be zero b/c under Q
Assert.Equal(stateManager.GetAlleleCount(1004, AlleleType.A, DirectionType.Reverse), 0);
for (int i = 1005; i <= 1015; i++)
{
var alleleType = i >= 1006 && i <= 1007 ? AlleleType.Deletion : AlleleType.A;
Assert.Equal(stateManager.GetAlleleCount(i, alleleType, DirectionType.Reverse), 0);
}
Assert.Equal(stateManager.GetAlleleCount(1116, AlleleType.A, DirectionType.Reverse), 0);
// ---------------------------------------
// Read beginning with deletion
// ---------------------------------------
var alignmentSet_frontEdge = TestHelper.CreateTestReads(
ReadTestHelper.CreateRead("chr1", "NNNNNTTTT", 1001, new CigarAlignment("5S2D4M")), lowQualityForRead,
ReadTestHelper.CreateRead("chr1", "AAAAAAAAA", 1005, new CigarAlignment("9M")), highQualityForRead);
stateManager = new RegionStateManager(false, minQualityThreshold);
var frontRead1 = alignmentSet_frontEdge[0];
var frontRead2 = alignmentSet_frontEdge[1];
foreach (var read in alignmentSet_frontEdge)
{
stateManager.AddAlleleCounts(read);
}
// check T counts
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.T, DirectionType.Forward), 0);
var lengthRef = ((Read)frontRead1).CigarData.GetReferenceSpan();
for (int i = 1001; i < 1001 + lengthRef - 1; i++)
{
var alleleType = i >= 1001 && i <= 1002 ? AlleleType.Deletion : AlleleType.T;
Assert.Equal(stateManager.GetAlleleCount(i, alleleType, DirectionType.Forward), 0); //dont add low Q ones
}
Assert.Equal(stateManager.GetAlleleCount(1014, AlleleType.T, DirectionType.Forward), 0);
// ---------------------------------------
// Terminal deletions
// ---------------------------------------
var alignmentSet_tailEdge = TestHelper.CreateTestReads(
ReadTestHelper.CreateRead("chr1", "TTTTNNNNN", 1001, new CigarAlignment("4M2D5S")), highQualityForRead,
ReadTestHelper.CreateRead("chr1", "AAAAAAAAA", 1015, new CigarAlignment("9M2D")), lowQualityForRead);//dont add low Q ones
var tailRead1 = alignmentSet_tailEdge[0];
var tailRead2 = alignmentSet_tailEdge[1];
stateManager = new RegionStateManager(false, minQualityThreshold);
for (var i = 0; i < tailRead2.SequencedBaseDirectionMap.Length; i++)
{
tailRead2.SequencedBaseDirectionMap[i] = DirectionType.Reverse;
}
foreach (var read in alignmentSet_tailEdge)
{
stateManager.AddAlleleCounts(read);
}
// check T counts
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.T, DirectionType.Forward), 0);
lengthRef = ((Read)tailRead1).CigarData.GetReferenceSpan();
var lastPos = 1001 + lengthRef - 1;
for (int i = 1001; i <= lastPos; i++)
{
var alleleType = i >= 1005 && i <= lastPos ? AlleleType.Deletion : AlleleType.T;
Assert.Equal(stateManager.GetAlleleCount(i, alleleType, DirectionType.Forward), 1);
}
Assert.Equal(stateManager.GetAlleleCount((int)lastPos + 1, AlleleType.Deletion, DirectionType.Forward), 0);
// check A counts
Assert.Equal(stateManager.GetAlleleCount(1014, AlleleType.A, DirectionType.Reverse), 0);
lengthRef = ((Read)tailRead2).CigarData.GetReferenceSpan();
lastPos = 1015 + lengthRef - 1;
for (int i = 1015; i <= lastPos; i++)
{
var alleleType = i >= 1024 && i <= lastPos ? AlleleType.Deletion : AlleleType.A;
Assert.Equal(stateManager.GetAlleleCount(i, alleleType, DirectionType.Reverse), 0);
}
Assert.Equal(stateManager.GetAlleleCount((int)lastPos + 1, AlleleType.Deletion, DirectionType.Reverse), 0);
}
public void AddAndGetAlleleCounts()
{
int minQuality = 25;
var stateManager = new RegionStateManager(false, minQuality);
var reads = TestHelper.CreateTestReads(
ReadTestHelper.CreateRead("chr1", "ACTGGCATC", 1001),
ReadTestHelper.CreateRead("chr1", "TCTGCCACT", 1005), minQuality).ToList();
var read1 = reads[0];
var read2 = reads[1];
for (var i = 0; i < read2.SequencedBaseDirectionMap.Length; i++)
{
read2.SequencedBaseDirectionMap[i] = DirectionType.Reverse;
}
read2.PositionMap.UpdatePositionAtIndex(7, -1, true);
var reads2 = TestHelper.CreateTestReads(
ReadTestHelper.CreateRead("chr1", "ACAC", 999), ReadTestHelper.CreateRead("chr1", "ACAC", 999), minQuality).ToList();
var secondRead1 = reads2[0];
var secondRead2 = reads2[1];
for (var i = 0; i < secondRead1.SequencedBaseDirectionMap.Length; i++)
{
secondRead1.SequencedBaseDirectionMap[i] = DirectionType.Stitched;
}
foreach (var read in reads)
{
stateManager.AddAlleleCounts(read);
}
foreach (var read in reads2)
{
stateManager.AddAlleleCounts(read);
}
Assert.Equal(stateManager.GetAlleleCount(1004, AlleleType.G, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1005, AlleleType.G, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1005, AlleleType.T, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1006, AlleleType.C, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1006, AlleleType.C, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1007, AlleleType.A, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1007, AlleleType.T, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1008, AlleleType.T, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1008, AlleleType.G, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1009, AlleleType.C, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1009, AlleleType.C, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1010, AlleleType.C, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1012, AlleleType.C, DirectionType.Reverse), 0); // not mapped to reference
Assert.Equal(stateManager.GetAlleleCount(999, AlleleType.A, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.C, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1002, AlleleType.C, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Forward), 2);
Assert.Equal(stateManager.GetAlleleCount(1002, AlleleType.C, DirectionType.Forward), 2);
// error conditions
Assert.Throws <ArgumentException>(() => stateManager.GetAlleleCount(0, AlleleType.A, DirectionType.Forward));
//allow some funky ref bases. just treat as N
//var badAlignmentSet = TestHelper.CreateTestReads(ReadTestHelper.CreateRead("chr1", "ACE", 999), minQuality);
//Assert.Throws<ArgumentException>(() => stateManager.AddAlleleCounts(badAlignmentSet));
// ---------------------------------------
// no calls and low quality bases should map to allele type N
// ---------------------------------------
var noCallAlignment = TestHelper.CreateTestReads(ReadTestHelper.CreateRead("chr1", "NNAC", 999), minQuality);
noCallAlignment[0].Qualities[2] = (byte)(minQuality - 1);
noCallAlignment[0].Qualities[3] = (byte)(minQuality - 1);
foreach (var read in noCallAlignment)
{
stateManager.AddAlleleCounts(read);
}
// make sure no calls logged
Assert.Equal(stateManager.GetAlleleCount(999, AlleleType.N, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.N, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1001, AlleleType.N, DirectionType.Forward), 1);
// make sure remaining didnt change
Assert.Equal(stateManager.GetAlleleCount(999, AlleleType.A, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.C, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1002, AlleleType.C, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Forward), 2);
Assert.Equal(stateManager.GetAlleleCount(1002, AlleleType.C, DirectionType.Forward), 2);
}
public void DoneProcessing()
{
var stateManager = new RegionStateManager();
var alignments = new List <AlignmentSet>
{
TestHelper.CreateTestSet(TestHelper.CreateRead("chr1", "A", 1)), // 1-1000
TestHelper.CreateTestSet(TestHelper.CreateRead("chr1", "A", 1001)), // 1001-2000
TestHelper.CreateTestSet(TestHelper.CreateRead("chr1", "A", 2001)), // 2001-3000
TestHelper.CreateTestSet(TestHelper.CreateRead("chr1", "A", 3001)), // 2001-3000
TestHelper.CreateTestSet(TestHelper.CreateRead("chr1", "A", 5001)), // 5001-6000
TestHelper.CreateTestSet(TestHelper.CreateRead("chr1", "A", 7001)) // 7001-8000
};
foreach (var alignment in alignments)
{
stateManager.AddAlleleCounts(alignment);
}
// blocks should all be in memory
Assert.Equal(1, stateManager.GetAlleleCount(1, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(2001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(3001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(5001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(7001, AlleleType.A, DirectionType.Forward));
stateManager.AddCandidates(new List <CandidateAllele>()
{
new CandidateAllele("chr1", 1, "T", "A", AlleleCategory.Snv),
new CandidateAllele("chr1", 3001, new string('A', 3500), "A", AlleleCategory.Deletion)
});
// still in memory
var batch = stateManager.GetCandidatesToProcess(1);
stateManager.DoneProcessing(batch);
Assert.Equal(1, stateManager.GetAlleleCount(1, AlleleType.A, DirectionType.Forward));
batch = stateManager.GetCandidatesToProcess(1500);
stateManager.DoneProcessing(batch);
Assert.Equal(1, stateManager.GetAlleleCount(1, AlleleType.A, DirectionType.Forward));
// block 1-1000 is the last accessed block so is still in memory, block 1001-2000 still in memory
batch = stateManager.GetCandidatesToProcess(2001);
stateManager.DoneProcessing(batch);
//Assert.Equal(0, stateManager.GetAlleleCount(1, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Forward));
// blocks 1001-2000 and 2001-3000 should be cleared
batch = stateManager.GetCandidatesToProcess(5500);
stateManager.DoneProcessing(batch);
Assert.Equal(0, stateManager.GetAlleleCount(1, AlleleType.A, DirectionType.Forward));
//Assert.Equal(0, stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Forward)); // last accessed block so this is stored in memory
Assert.Equal(0, stateManager.GetAlleleCount(2001, AlleleType.A, DirectionType.Forward));
Console.WriteLine("Check");
//3001 block shouldn't be cleared yet because it holds a variant that extends into a further block
Assert.Equal(1, stateManager.GetAlleleCount(3001, AlleleType.A, DirectionType.Forward));
//5001 block shouldn't be cleared yet because it comes later than a held-up block
Assert.Equal(1, stateManager.GetAlleleCount(5001, AlleleType.A, DirectionType.Forward));
batch = stateManager.GetCandidatesToProcess(6500);
stateManager.DoneProcessing(batch);
//3001 block shouldn't be cleared yet because it holds a variant that extends into a further block
Assert.Equal(1, stateManager.GetAlleleCount(3001, AlleleType.A, DirectionType.Forward));
//5001 block shouldn't be cleared yet because it comes later than a held-up block
Assert.Equal(1, stateManager.GetAlleleCount(5001, AlleleType.A, DirectionType.Forward));
batch = stateManager.GetCandidatesToProcess(7001);
stateManager.DoneProcessing(batch);
Assert.Equal(0, stateManager.GetAlleleCount(3001, AlleleType.A, DirectionType.Forward));
Assert.Equal(1, stateManager.GetAlleleCount(5001, AlleleType.A, DirectionType.Forward)); //Still here because it's the last accessed block
Assert.Equal(1, stateManager.GetAlleleCount(7001, AlleleType.A, DirectionType.Forward));
batch = stateManager.GetCandidatesToProcess(7002);
stateManager.DoneProcessing(batch);
Assert.Equal(0, stateManager.GetAlleleCount(3001, AlleleType.A, DirectionType.Forward));
Assert.Equal(0, stateManager.GetAlleleCount(5001, AlleleType.A, DirectionType.Forward));
// rest should be cleared - Not anymore!!!
//stateManager.DoneProcessing();
//Assert.Equal(0, stateManager.GetAlleleCount(5001, AlleleType.A, DirectionType.Forward));
//Assert.Equal(0, stateManager.GetAlleleCount(7001, AlleleType.A, DirectionType.Forward));
}
public void AddAndGetAlleleCounts()
{
int minQuality = 25;
var stateManager = new RegionStateManager(false, minQuality);
var alignmentSet = TestHelper.CreateTestSet(
TestHelper.CreateRead("chr1", "ACTGGCATC", 1001),
TestHelper.CreateRead("chr1", "TCTGCCACT", 1005), minQuality);
for (var i = 0; i < alignmentSet.PartnerRead2.DirectionMap.Length; i++)
{
alignmentSet.PartnerRead2.DirectionMap[i] = DirectionType.Reverse;
}
alignmentSet.PartnerRead2.PositionMap[7] = -1;
var alignmentSet2 = TestHelper.CreateTestSet(
TestHelper.CreateRead("chr1", "ACAC", 999), TestHelper.CreateRead("chr1", "ACAC", 999), minQuality);
for (var i = 0; i < alignmentSet2.PartnerRead1.DirectionMap.Length; i++)
{
alignmentSet2.PartnerRead1.DirectionMap[i] = DirectionType.Stitched;
}
stateManager.AddAlleleCounts(alignmentSet);
stateManager.AddAlleleCounts(alignmentSet2);
Assert.Equal(stateManager.GetAlleleCount(1004, AlleleType.G, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1005, AlleleType.G, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1005, AlleleType.T, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1006, AlleleType.C, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1006, AlleleType.C, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1007, AlleleType.A, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1007, AlleleType.T, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1008, AlleleType.T, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1008, AlleleType.G, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1009, AlleleType.C, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1009, AlleleType.C, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1010, AlleleType.C, DirectionType.Reverse), 1);
Assert.Equal(stateManager.GetAlleleCount(1012, AlleleType.C, DirectionType.Reverse), 0); // not mapped to reference
Assert.Equal(stateManager.GetAlleleCount(999, AlleleType.A, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.C, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1002, AlleleType.C, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Forward), 2);
Assert.Equal(stateManager.GetAlleleCount(1002, AlleleType.C, DirectionType.Forward), 2);
// error conditions
Assert.Throws <ArgumentException>(() => stateManager.GetAlleleCount(0, AlleleType.A, DirectionType.Forward));
//tjd + allow some funky ref bases. just treat as N
//var badAlignmentSet = TestHelper.CreateTestSet(TestHelper.CreateRead("chr1", "ACE", 999), minQuality);
//Assert.Throws<ArgumentException>(() => stateManager.AddAlleleCounts(badAlignmentSet));
//tjd-
// ---------------------------------------
// no calls and low quality bases should map to allele type N
// ---------------------------------------
var noCallAlignment = TestHelper.CreateTestSet(TestHelper.CreateRead("chr1", "NNAC", 999), minQuality);
noCallAlignment.PartnerRead1.Qualities[2] = (byte)(minQuality - 1);
noCallAlignment.PartnerRead1.Qualities[3] = (byte)(minQuality - 1);
stateManager.AddAlleleCounts(noCallAlignment);
// make sure no calls logged
Assert.Equal(stateManager.GetAlleleCount(999, AlleleType.N, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.N, DirectionType.Forward), 1);
Assert.Equal(stateManager.GetAlleleCount(1001, AlleleType.N, DirectionType.Forward), 1);
// make sure remaining didnt change
Assert.Equal(stateManager.GetAlleleCount(999, AlleleType.A, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1000, AlleleType.C, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1002, AlleleType.C, DirectionType.Stitched), 1);
Assert.Equal(stateManager.GetAlleleCount(1001, AlleleType.A, DirectionType.Forward), 2);
Assert.Equal(stateManager.GetAlleleCount(1002, AlleleType.C, DirectionType.Forward), 2);
}
