public static Tuple <Dictionary <int, List <LoadTestResult> >, List <Domain.Models.Alleles.CandidateAllele> > LoadReads
(List <BamAlignment> reads, PiscesApplicationOptions options, ChrReference chrRef,
bool expectedvariants, string expectedLoading, string expectedDirectionString)
{
RegionStateManager manager = new RegionStateManager(expectStitchedReads: true);
var variantFinder = new CandidateVariantFinder(options.BamFilterParameters.MinimumBaseCallQuality, options.MaxSizeMNV, options.MaxGapBetweenMNV, options.CallMNVs);
var candidateVariants = new List <Domain.Models.Alleles.CandidateAllele>();
try
{
foreach (var b in reads)
{
if (b == null)
{
continue;
}
var r = new Read(chrRef.Name, b);
// find candidate variants
candidateVariants = variantFinder.FindCandidates(r, chrRef.Sequence, chrRef.Name).ToList();
// track in state manager
manager.AddCandidates(candidateVariants);
manager.AddAlleleCounts(r);
}
Dictionary <int, List <LoadTestResult> > countResults = GetCountsFromManager(manager);
var loadingResults = Tuple.Create(countResults, candidateVariants);
return(loadingResults);
}
catch
{
return(null);
}
}
public void AddAndGetCollapsedCount_NonCollapsedBAM(ReadCollapsedType type)
{
int minQuality = 20;
// non collapsed BAM (no reco @PG line in BAM header)
var stateManager = new RegionStateManager(false, minQuality, expectStitchedReads: true);
var readpair = ReadTestHelper.CreateProperReadPair("test", 6, type, pos: 10, matePos: 15);
stateManager.AddAlleleCounts(readpair.Item1);
stateManager.AddAlleleCounts(readpair.Item2);
Assert.Equal(0, stateManager.GetCollapsedReadCount(10, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(11, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(12, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(13, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(14, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(15, type)); // overlapping
Assert.Equal(0, stateManager.GetCollapsedReadCount(16, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(17, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(18, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(19, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(20, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(9, type));
}
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);
}
