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 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));
}
private void ExecuteAddAndGetCandidates(bool trackOpenEnded)
{
var stateManager = new RegionStateManager(false, trackOpenEnded: trackOpenEnded);
var candidates = new List <CandidateAllele>();
// block 1-1000
candidates.Add(new CandidateAllele("chr1", 1, "A", "T", AlleleCategory.Snv));
candidates.Add(new CandidateAllele("chr1", 998, "AT", "A", AlleleCategory.Deletion));
candidates.Add(new CandidateAllele("chr1", 1000, "A", "T", AlleleCategory.Snv));
// block 1001-2000
candidates.Add(new CandidateAllele("chr1", 1001, "A", "T", AlleleCategory.Snv));
candidates.Add(new CandidateAllele("chr1", 1001, "A", "G", AlleleCategory.Snv));
// block 2001-3000
candidates.Add(new CandidateAllele("chr1", 3000, "ATCC", "GAGG", AlleleCategory.Mnv)); // spans blocks
// block 3001-4000
candidates.Add(new CandidateAllele("chr1", 3001, "AT", "A", AlleleCategory.Deletion)); // not collapsable
candidates.Add(new CandidateAllele("chr1", 3002, "T", "A", AlleleCategory.Snv)); // collapsable competing target
candidates.Add(new CandidateAllele("chr1", 3003, "G", "C", AlleleCategory.Snv)
{
OpenOnRight = true
}); // not collapsable
candidates.Add(new CandidateAllele("chr1", 3002, "TA", "GA", AlleleCategory.Mnv)); // collapsable competing target
candidates.Add(new CandidateAllele("chr1", 3001, "TACGG", "GAGAA", AlleleCategory.Mnv)); // not competing target (past max)
//block 5001-6000
candidates.Add(new CandidateAllele("chr1", 5005, "AC", "TT", AlleleCategory.Mnv));
stateManager.AddCandidates(candidates);
// make sure we only get candidates from cleared blocks (plus any collapsable ones)
// make sure we only get a batch at all after upToPosition has transitioned blocks
// first time we always get a batch
var batch = stateManager.GetCandidatesToProcess(1);
Assert.Equal(0, batch.GetCandidates().Count);
Assert.Equal(null, batch.ClearedRegions);
// no batch expected - haven't transitioned to next block
batch = stateManager.GetCandidatesToProcess(1000);
Assert.Equal(null, batch);
// onto next block - should get all candidates in block 1
batch = stateManager.GetCandidatesToProcess(1002);
VerifyBatchContents(batch, candidates.Where(c => c.ReferencePosition <= 1000).ToList());
Assert.Equal(1, batch.ClearedRegions[0].StartPosition);
Assert.Equal(1000, batch.ClearedRegions[0].EndPosition);
stateManager.DoneProcessing(batch);
// make sure "done" batch is cleared from state
// expect second block only
batch = stateManager.GetCandidatesToProcess(2001); // next block
VerifyBatchContents(batch, candidates.Where(c => c.ReferencePosition == 1001).ToList());
Assert.Equal(1001, batch.ClearedRegions[0].StartPosition);
Assert.Equal(2000, batch.ClearedRegions[0].EndPosition);
stateManager.DoneProcessing(batch);
// make sure we fetch collapsable from future blocks
batch = stateManager.GetCandidatesToProcess(3003);
VerifyBatchContents(batch, candidates.Where(c => c.ReferencePosition > 1001 &&
(c.ReferencePosition <= 3000 || // properly from batch
(trackOpenEnded &&
((c.Type == AlleleCategory.Mnv || c.Type == AlleleCategory.Snv) && // OR collapsable from future batch (if collapsing is on)
c.ReferencePosition + c.AlternateAllele.Length - 1 <= 3003 &&
!c.OpenOnRight))
)).ToList());
Assert.Equal(2001, batch.ClearedRegions[0].StartPosition);
Assert.Equal(3000, batch.ClearedRegions[0].EndPosition);
// repeat - blocks weren't cleared from previous batch
// expect all candidates in cleared batches minus the collapsable ones we extracted (those were removed from batch)
batch = stateManager.GetCandidatesToProcess(4001);
VerifyBatchContents(batch, candidates.Where(c => c.ReferencePosition > 1001 && c.ReferencePosition < 4000 && c.ReferencePosition != 3002 || (!trackOpenEnded &&
((c.Type == AlleleCategory.Mnv || c.Type == AlleleCategory.Snv) &&
c.ReferencePosition + c.AlternateAllele.Length - 1 <= 3003 &&
!c.OpenOnRight && c.ReferencePosition == 3002))
).ToList());
Assert.Equal(2001, batch.ClearedRegions[0].StartPosition);
Assert.Equal(3000, batch.ClearedRegions[0].EndPosition);
Assert.Equal(3001, batch.ClearedRegions[1].StartPosition);
Assert.Equal(4000, batch.ClearedRegions[1].EndPosition);
// make sure can fetch all - upToPosition is null
batch = stateManager.GetCandidatesToProcess(null);
VerifyBatchContents(batch, candidates.Where(c => c.ReferencePosition > 1001 && (!trackOpenEnded || c.ReferencePosition != 3002)).ToList());
Assert.Equal(3, batch.ClearedRegions.Count);
stateManager.DoneProcessing(batch);
// make sure empty state is ok
batch = stateManager.GetCandidatesToProcess(null);
Assert.Equal(0, batch.GetCandidates().Count);
Assert.Equal(null, batch.ClearedRegions);
}
public void AddAndGetCandidates()
{
var stateManager = new RegionStateManager();
var candidates = new List <CandidateAllele>();
// block 1-1000
candidates.Add(new CandidateAllele("chr1", 1, "A", "T", AlleleCategory.Snv));
candidates.Add(new CandidateAllele("chr1", 999, "AT", "A", AlleleCategory.Deletion));
candidates.Add(new CandidateAllele("chr1", 1000, "A", "T", AlleleCategory.Snv));
// block 1001-2000
candidates.Add(new CandidateAllele("chr1", 1001, "A", "T", AlleleCategory.Snv));
candidates.Add(new CandidateAllele("chr1", 1001, "A", "G", AlleleCategory.Snv));
// block 2001-3000
candidates.Add(new CandidateAllele("chr1", 3000, "AT", "A", AlleleCategory.Deletion));
// block 3001-4000
candidates.Add(new CandidateAllele("chr1", 3001, "AT", "A", AlleleCategory.Deletion));
stateManager.AddCandidates(candidates);
// make sure two block window is enforced
var batch = stateManager.GetCandidatesToProcess(1);
Assert.Equal(0, batch.GetCandidates().Count);
Assert.Equal(null, batch.ClearedRegions);
batch = stateManager.GetCandidatesToProcess(1000);
Assert.Equal(0, batch.GetCandidates().Count);
Assert.Equal(null, batch.ClearedRegions);
batch = stateManager.GetCandidatesToProcess(1500);
Assert.Equal(0, batch.GetCandidates().Count);
Assert.Equal(null, batch.ClearedRegions);
batch = stateManager.GetCandidatesToProcess(2000);
Assert.Equal(0, batch.GetCandidates().Count);
batch = stateManager.GetCandidatesToProcess(2001); // officially on another block
VerifyBatchContents(batch, candidates.Where(c => c.Coordinate <= 1000));
Assert.Equal(1, batch.ClearedRegions[0].StartPosition);
Assert.Equal(1000, batch.ClearedRegions[0].EndPosition);
stateManager.DoneProcessing(batch);
// make sure candidate already fetched isn't still in state
batch = stateManager.GetCandidatesToProcess(2001);
Assert.Equal(0, batch.GetCandidates().Count);
Assert.Equal(null, batch.ClearedRegions);
// make sure can fetch across multiple
batch = stateManager.GetCandidatesToProcess(4000);
VerifyBatchContents(batch, candidates.Where(c => c.Coordinate >= 1001 && c.Coordinate <= 3000));
stateManager.DoneProcessing(batch);
Assert.Equal(1001, batch.ClearedRegions[0].StartPosition);
Assert.Equal(2000, batch.ClearedRegions[0].EndPosition);
Assert.Equal(2001, batch.ClearedRegions[1].StartPosition);
Assert.Equal(3000, batch.ClearedRegions[1].EndPosition);
stateManager.AddCandidates(new List <CandidateAllele>
{
new CandidateAllele("chr1", 2001, "A", "ATG", AlleleCategory.Insertion)
});
// make sure can fetch remaining
batch = stateManager.GetCandidatesToProcess(null);
Assert.Equal(2, batch.GetCandidates().Count);
stateManager.DoneProcessing(batch);
Assert.Equal(2001, batch.ClearedRegions[0].StartPosition);
Assert.Equal(3000, batch.ClearedRegions[0].EndPosition);
Assert.Equal(3001, batch.ClearedRegions[1].StartPosition);
Assert.Equal(4000, batch.ClearedRegions[1].EndPosition);
// make sure empty state is ok
batch = stateManager.GetCandidatesToProcess(null);
Assert.Equal(0, batch.GetCandidates().Count);
Assert.Equal(null, batch.ClearedRegions);
}
