public void Pisces_MergeReadsWithInsertionTests()
{
//Migrated from old Pisces: Originally called Pisces_MergeReadsWithInsertionTests
var read1 = ReadTestHelper.CreateRead("chr1",
"GAAAATGTGCAGAAGAGGATAGGCAGAAACTCAAAAAAACATATAGACAATAACACCAGCACTCCTCCAAATTGCCCAATACTATATACTAAGATTTGTA",
115251051,
new CigarAlignment("25S7M1I67M"),
new byte[100],
110);
var read2 = ReadTestHelper.CreateRead("chr1",
"AATTGCCCAATACTATATACTAAGATTTGTAATTATGCCAAGAAACCATATGCTCACCTTGTTACATCACCACACATGGCAATCCCATACAACCCTGAGT",
115251094,
new CigarAlignment("75M25S"),
new byte[100],
88);
TestSuccesfullyStitchedRead(read1, read2, 0, "25S7M1I111M25S", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal(mergedRead.Sequence,
"GAAAATGTGCAGAAGAGGATAGGCAGAAACTCAAAAAAACATATAGACAATAACACCAGCACTCCTCCAAATTGCCCAATACTATATACTAAGATTTGTAATTATGCCAAGAAACCATATGCTCACCTTGTTACATCACCACACATGGCAATCCCATACAACCCTGAGT");
});
}
public void GetAlignementCollapsedType_NonProperReadPair(DirectionType type, string orientation)
{
var nonProperReadPair = ReadTestHelper.CreateNonProperReadPair("test", 6, type, orientation, pos: 10, matePos: 15, minBaseQuality: 30);
Assert.Null(nonProperReadPair.Item1.GetReadCollapsedType(type));
Assert.Null(nonProperReadPair.Item2.GetReadCollapsedType(type));
}
public void Constructor()
{
var read1 = ReadTestHelper.CreateRead("chr1", "ACT", 100);
var read2 = ReadTestHelper.CreateRead("chr1", "TCCT", 200);
var alignmentSet = new AlignmentSet(read1, read2);
Assert.Equal(read1, alignmentSet.PartnerRead1);
Assert.Equal(read2, alignmentSet.PartnerRead2);
Assert.True(alignmentSet.IsFullPair);
// read1 must be provided
Assert.Throws <ArgumentException>(() => new AlignmentSet(null, read1));
// allow single read
alignmentSet = new AlignmentSet(read1, null);
Assert.Equal(read1, alignmentSet.PartnerRead1);
Assert.Equal(null, alignmentSet.PartnerRead2);
Assert.False(alignmentSet.IsFullPair);
// make sure reads are ordered
alignmentSet = new AlignmentSet(read2, read1);
Assert.Equal(read1, alignmentSet.PartnerRead1);
Assert.Equal(read2, alignmentSet.PartnerRead2);
Assert.True(alignmentSet.IsFullPair);
}
public static AlignmentSet GetOverlappingReadSet(bool withXCTag = false)
{
var read1 = ReadTestHelper.CreateRead("chr1", "ATCGATCG", 12345, new CigarAlignment("8M"), qualityForAll: 30);
var read2_overlap = ReadTestHelper.CreateRead("chr1", "ATCGTT", 12349, new CigarAlignment("6M"), qualityForAll: 30);
return(new AlignmentSet(read1, read2_overlap));
}
public void TryStitch_SoftclipScenarios()
{
//Migrated from old Pisces: Originally called Pisces_MergeRead2First
var sequence =
"GG" + "GGCCACGCGGGGAGCAGCCTCTGGCATTCTGGGAGCTTCATCTGGACCTGGGTCTTCAGTGAACCATTGTTCAATATCGTCCGGGGACAGCATCAAATCATCCATTGCTTGGGACGGCAAGG" + "GGGACTGTAGATGGGTGAAAAGAGCA";
var read1 = ReadTestHelper.CreateRead("chr1",
sequence,
7579464,
new CigarAlignment("2S122M26S"),
Enumerable.Repeat((byte)30, sequence.Length).ToArray(),
7579464);
StitcherTestHelpers.SetReadDirections(read1, DirectionType.Forward);
sequence =
"GTGTAGGAGCTGCTGGTGCAGG" + "GGCCACGCGGGGAGCAGCCTCTGGCATTCTGGGAGCTTCATCTGGACCTGGGTCTTCAGTGAACAATTGTTCAATATCGTCCGGGGCCAGCATCAAATCATCCATTGCTTGGGACGGCAAGG" + "GGGACT";
var read2 = ReadTestHelper.CreateRead("chr1",
sequence,
7579464,
new CigarAlignment("22S122M6S"),
Enumerable.Repeat((byte)30, sequence.Length).ToArray(),
7579464);
StitcherTestHelpers.SetReadDirections(read2, DirectionType.Reverse);
string expectedWithNify =
"GTGTAGGAGCTGCTGGTGCAGG" + "GGCCACGCGGGGAGCAGCCTCTGGCATTCTGGGAGCTTCATCTGGACCTGGGTCTTCAGTGAACNATTGTTCAATATCGTCCGGGGNCAGCATCAAATCATCCATTGCTTGGGACGGCAAGG" + "GGGACTGTAGATGGGTGAAAAGAGCA";
string expectedWithNoNify =
"GTGTAGGAGCTGCTGGTGCAGG" + "GGCCACGCGGGGAGCAGCCTCTGGCATTCTGGGAGCTTCATCTGGACCTGGGTCTTCAGTGAACCATTGTTCAATATCGTCCGGGGACAGCATCAAATCATCCATTGCTTGGGACGGCAAGG" + "GGGACTGTAGATGGGTGAAAAGAGCA";
// both reads have the same reference position, but read2 really starts earlier
// make sure we behave properly
TestSuccesfullyStitchedRead(read1, read2, 0, "22S122M26S", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal("22R122S26F", mergedRead.CigarDirections.ToString());
Assert.Equal(expectedWithNify, mergedRead.Sequence);
}, nifyDisagreements: true);
// Test with allowing probe softclips to merge
TestSuccesfullyStitchedRead(read1, read2, 0, "22S122M26S", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal("20R130S20F", mergedRead.CigarDirections.ToString());
Assert.Equal(expectedWithNify, mergedRead.Sequence);
}, nifyDisagreements: true, ignoreProbeSoftclips: false);
//here, the Q scores where we disagree are equal (30) so we give R1 the preference (R1 usually being better than R2, if we are forced to pick one)
read1.BamAlignment.SetIsFirstMate(true);
read2.BamAlignment.SetIsFirstMate(false);
TestSuccesfullyStitchedRead(read1, read2, 0, "22S122M26S", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal(expectedWithNoNify, mergedRead.Sequence);
}, nifyDisagreements: false);
}
public void AddAndGetCollapsedCountHappyPath(ReadCollapsedType type)
{
int minQuality = 25;
var stateManager = new CollapsedRegionStateManager(false, minQuality);
var readpair = ReadTestHelper.CreateProperReadPair("test", 6, type, pos: 10, matePos: 15, minBaseQuality: 30);
stateManager.AddAlleleCounts(readpair.Item1);
stateManager.AddAlleleCounts(readpair.Item2);
Assert.Equal(1, stateManager.GetCollapsedReadCount(10, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(11, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(12, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(13, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(14, type));
Assert.Equal(2, stateManager.GetCollapsedReadCount(15, type)); // overlapping
Assert.Equal(1, stateManager.GetCollapsedReadCount(16, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(17, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(18, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(19, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(20, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(9, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(21, type));
// test SimplexStitched which is not a primative type.
if (type == ReadCollapsedType.SimplexForwardStitched || type == ReadCollapsedType.SimplexReverseStitched)
{
Assert.Equal(1, stateManager.GetCollapsedReadCount(10, ReadCollapsedType.SimplexStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(11, ReadCollapsedType.SimplexStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(12, ReadCollapsedType.SimplexStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(13, ReadCollapsedType.SimplexStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(14, ReadCollapsedType.SimplexStitched));
Assert.Equal(2, stateManager.GetCollapsedReadCount(15, ReadCollapsedType.SimplexStitched)); // overlapping
Assert.Equal(1, stateManager.GetCollapsedReadCount(16, ReadCollapsedType.SimplexStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(17, ReadCollapsedType.SimplexStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(18, ReadCollapsedType.SimplexStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(19, ReadCollapsedType.SimplexStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(20, ReadCollapsedType.SimplexStitched));
Assert.Equal(0, stateManager.GetCollapsedReadCount(9, ReadCollapsedType.SimplexStitched));
Assert.Equal(0, stateManager.GetCollapsedReadCount(21, ReadCollapsedType.SimplexStitched));
}
// test SimplexNonStitched which is also not a primative type.
if (type == ReadCollapsedType.SimplexForwardNonStitched || type == ReadCollapsedType.SimplexReverseNonStitched)
{
Assert.Equal(1, stateManager.GetCollapsedReadCount(10, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(11, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(12, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(13, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(14, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(2, stateManager.GetCollapsedReadCount(15, ReadCollapsedType.SimplexNonStitched)); // overlapping
Assert.Equal(1, stateManager.GetCollapsedReadCount(16, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(17, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(18, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(19, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(1, stateManager.GetCollapsedReadCount(20, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(0, stateManager.GetCollapsedReadCount(9, ReadCollapsedType.SimplexNonStitched));
Assert.Equal(0, stateManager.GetCollapsedReadCount(21, ReadCollapsedType.SimplexNonStitched));
}
}
public void AddAndGetCollapsedCount_Exceptions(ReadCollapsedType type)
{
int minQuality = 20;
// collapsed and stitched BAM
var stateManager = new CollapsedRegionStateManager(false, minQuality);
var noncollapsedRead = ReadTestHelper.CreateRead("test", ReadTestHelper.RandomBases(6, "ACGTN"), 10, matePosition: 15);
Assert.Throws <Exception>(() => stateManager.AddAlleleCounts(noncollapsedRead));
}
public void Pisces_MergeBugExample()
{
//Migrated from old Pisces: Originally called Pisces_MergeBugExample
//test1: happy path
//0 1 2 3 4 5 6 7 8 9
//- C A T A T
//- - - - A T A G G
var read1 = ReadTestHelper.CreateRead("chr1",
"TAAAGGTTTTGCTATCGGCATGCCAGTGTGCGAATTTGATATGGTTAAAGATCCAGAAGTACAGGACTTCCGCAGAAATATTTTGAACGTTTGTAAAGAA",
178917497,
new CigarAlignment("25S75M"),
new byte[]
{
27, 28, 11, 28, 27, 29, 20, 20, 31, 31, 31, 31, 27, 27, 32, 31, 29, 34, 34, 29, 34, 11, 12, 12, 23, 12,
23, 12, 23, 32, 13, 22, 10, 20, 10, 32, 36, 34, 28, 31, 13, 13, 24, 32, 24, 13, 24, 32, 31, 37, 36,
12, 31, 12, 12, 12, 13, 12, 20, 12, 12, 32, 28, 12, 12, 20, 10, 20, 32, 20, 32, 10, 10, 20, 9, 9, 20,
36, 12, 12, 12, 34, 12, 12, 23, 27, 32, 12, 23, 23, 23, 12, 20, 10, 11, 11, 28, 20, 34, 10
},
178917546);
var read2 = ReadTestHelper.CreateRead("chr1",
"GAAATATTCTGAACGTTTGTAAAGAAGCTGTGGATCTTAGGGACCTCAATTCACCTCATAGTAGAACAATGTATGTCTATCCTCCAAATGTAGAATCTTC",
178917546,
new CigarAlignment("71M29S"),
new byte[]
{
36, 33, 37, 37, 32, 14, 33, 36, 34, 32, 36, 23, 11, 20, 30, 35, 37, 35, 28, 38, 33, 30, 32, 12, 35, 39,
37, 37, 36, 32, 32, 23, 14, 14, 32, 32, 37, 32, 23, 12, 30, 22, 23, 12, 32, 32, 14, 32, 15, 34, 30,
22, 14, 36, 30, 34, 31, 39, 39, 39, 38, 39, 39, 38, 34, 36, 30, 34, 34, 30, 34, 34, 34, 32, 32, 33,
34, 37, 37, 31, 36, 37, 30, 37, 33, 30, 33, 31, 33, 33, 33, 33, 33, 33, 33, 30, 30, 30, 30, 30
},
178917497);
//expected overlap
//"TAAAG GTTTT GCTAT CGGCA TGCCA GTGTG CGAAT TTGAT ATGGT TAAAG ATCCA GAAGT ACAGG ACTTC CGCAG AAATA TTTTG AACGT TTGTA AAGAA";
// "G AAATA TTCTG AACGT TTGTA AAGAA GCTGT GGATCTTAGGGACCTCAATTCACCTCATAGTAGAACAATGTATGTCTATCCTCCAAATGTAGAATCTTC";
// 0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75
TestSuccesfullyStitchedRead(read2, read1, 0, "25S120M29S", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal(mergedRead.Sequence, "TAAAGGTTTTGCTATCGGCATGCCAGTGTGCGAATTTGATATGGTTAAAGATCCAGAAGTACAGGACTTCCGCAGAAATATTNTGAACGTTTGTAAAGAAGCTGTGGATCTTAGGGACCTCAATTCACCTCATAGTAGAACAATGTATGTCTATCCTCCAAATGTAGAATCTTC");
Assert.Equal(mergedRead.Qualities[0], (byte)27);
Assert.Equal(mergedRead.Qualities[1], (byte)28);
Assert.Equal(mergedRead.Qualities[2], (byte)11);
//overlap is "G AAATA TTTTG AACGT TTGTA AAGAA", string at index 74
byte r1 = read1.Qualities[74];
byte r2 = read2.Qualities[0];
Assert.Equal(mergedRead.Qualities[74], (byte)(Convert.ToInt32(r1) + Convert.ToInt32(r2)));
}, true);
}
public void GetReadCollapsedType(ReadCollapsedType readCollapsedType)
{
var readpair = ReadTestHelper.CreateProperReadPair("test", 6, readCollapsedType, pos: 10, matePos: 15, minBaseQuality: 30);
for (int i = 0; i <= 5; i++)
{
DirectionType direction = readpair.Item1.SequencedBaseDirectionMap[i];
Assert.Equal(readCollapsedType, readpair.Item1.GetReadCollapsedType(direction));
direction = readpair.Item2.SequencedBaseDirectionMap[i];
Assert.Equal(readCollapsedType, readpair.Item2.GetReadCollapsedType(direction));
}
}
private void AddReads(List <Read> readSets, int copies, int read1Position, string read1Sequence,
int read2Position, string read2Sequence)
{
for (var i = 0; i < copies; i++)
{
readSets.AddRange(new List <Read>()
{
ReadTestHelper.CreateRead(_chrName, read1Sequence, read1Position, new CigarAlignment("6M"),
qualityForAll: 30),
ReadTestHelper.CreateRead(_chrName, read2Sequence, read2Position, new CigarAlignment("6M"),
qualityForAll: 30)
}
);
}
}
public void IsReadCollapsed()
{
var alignment = new BamAlignment
{
Bases = "ACTC",
Position = 5,
MapQuality = 343,
MatePosition = 12312,
Qualities = new[] { (byte)20, (byte)21, (byte)30, (byte)40 },
CigarData = new CigarAlignment("1S3M")
};
var read = new Read("chr1", alignment);
Assert.False(read.IsCollapsedRead());
alignment.TagData = ReadTestHelper.GetReadCountsTagData(1, 10); // set XV and XW tags
Assert.True(read.IsCollapsedRead());
}
public void Pisces_MergeReadsWithDeletionTests()
{
//Migrated from old Pisces: Originally called Pisces_MergeReadsWithDeletionTests
var read1 = ReadTestHelper.CreateRead("chr1",
"GAAAATGTGCAGAAGAGGATAGGCAGAAACTCAAAAAACATATAGACAATAACACCAGCACTCCTCCAAATTGCCCAATACTATATACTAAGATTTGTAA",
115251051,
new CigarAlignment("25S75M"),
new byte[100],
110);
var read2 = ReadTestHelper.CreateRead("chr1",
"CCAAATTGCCCAATACTATATACTAAGATTTGTAATTATGCCAAGAAACCATATGCTCACCTTGTTACATCACACATGGCAATCCCATACAACCCTGAGT",
115251091,
new CigarAlignment("70M3D5M25S"),
new byte[100],
88);
var action = new Action <Read>((mergedRead1) =>
{
Assert.NotNull(mergedRead1);
Assert.Equal(mergedRead1.Sequence,
"GAAAATGTGCAGAAGAGGATAGGCAGAAACTCAAAAAACATATAGACAATAACACCAGCACTCCTCCAAATTGCCCAATACTATATACTAAGATTTGTAATTATGCCAAGAAACCATATGCTCACCTTGTTACATCACACATGGCAATCCCATACAACCCTGAGT");
});
TestSuccesfullyStitchedRead(read1, read2, 0, "25S110M3D5M25S", action);
read1 = ReadTestHelper.CreateRead("chr1",
"GAAAATGTGCAGAAGAGGATAGGCAGAAACTCAAAAAACATATAGACAATAACACCAGCACTCCTCCAAATTGCCCAATACTATATACTAAGATTTGTAA",
115251051,
new CigarAlignment("25S75M"),
new byte[100],
110);
read2 = ReadTestHelper.CreateRead("chr1",
"CCAAATTGCCCAATACTATATACTAAGATTTGTAATTATGCCAAGAAACCATATGCTCACCTTGTTACATCACACATGGCAATCCCATACAACCCTGAGT",
115251091,
new CigarAlignment("70M3D5M25S"),
new byte[100],
88);
TestSuccesfullyStitchedRead(read2, read1, 0, "25S110M3D5M25S", action);
}
public void AddAndGetAlleleCounts_BlockReset(ReadCollapsedType type)
{
int minQuality = 25;
var stateManager = new CollapsedRegionStateManager(false, minQuality);
var readpair = ReadTestHelper.CreateProperReadPair("test", 6, type, pos: 10, matePos: 15, minBaseQuality: 30);
stateManager.AddAlleleCounts(readpair.Item1);
stateManager.AddAlleleCounts(readpair.Item2);
Assert.Equal(1, stateManager.GetCollapsedReadCount(10, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(11, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(12, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(13, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(14, type));
Assert.Equal(2, stateManager.GetCollapsedReadCount(15, type)); // overlapping
Assert.Equal(1, stateManager.GetCollapsedReadCount(16, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(17, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(18, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(19, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(20, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(9, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(21, type));
var batch = stateManager.GetCandidatesToProcess(2001);
stateManager.DoneProcessing(batch); // trigger block reset
stateManager.AddAlleleCounts(readpair.Item1);
stateManager.AddAlleleCounts(readpair.Item2);
Assert.Equal(1, stateManager.GetCollapsedReadCount(10, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(11, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(12, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(13, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(14, type));
Assert.Equal(2, stateManager.GetCollapsedReadCount(15, type)); // overlapping
Assert.Equal(1, stateManager.GetCollapsedReadCount(16, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(17, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(18, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(19, type));
Assert.Equal(1, stateManager.GetCollapsedReadCount(20, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(9, type));
Assert.Equal(0, stateManager.GetCollapsedReadCount(21, type));
}
public Read GetAlignmentWithCoverageDirections(int numForward, int numStitched, int numReverse, int deletionLength, bool isDuplex = false)
{
var expandedSeqLength = numForward + numStitched + numReverse;
var cigarData = new CigarAlignment((expandedSeqLength - deletionLength) + "M");
if (deletionLength > 0)
{
cigarData = (VariantStartInRead == 0) ?
new CigarAlignment(deletionLength + "D" + (expandedSeqLength - deletionLength - VariantStartInRead) + "M") :
new CigarAlignment(VariantStartInRead + "M" + deletionLength + "D" + (expandedSeqLength - deletionLength - VariantStartInRead) + "M");
}
var read = ReadTestHelper.CreateRead("chr1", String.Concat(Enumerable.Repeat("A", numForward + numReverse + numStitched - deletionLength)), 1, cigarData);
read.SequencedBaseDirectionMap = GetCoverageDirections(numForward, numStitched, numReverse, deletionLength);
read.CigarDirections = GetCigarDirection(numForward, numStitched, numReverse);
read.IsDuplex = isDuplex;
return(read);
}
public void ReadCollapsedCounts()
{
var alignment = new BamAlignment
{
Bases = "ACTC",
Position = 5,
MapQuality = 343,
MatePosition = 12312,
Qualities = new[] { (byte)20, (byte)21, (byte)30, (byte)40 },
CigarData = new CigarAlignment("1S3M")
};
alignment.TagData = ReadTestHelper.GetReadCountsTagData(5, 10);
var read = new Read("chr1", alignment);
Assert.True(read.IsDuplex);
alignment.TagData = ReadTestHelper.GetReadCountsTagData(0, 5); // first tag is 0
read = new Read("chr1", alignment);
Assert.False(read.IsDuplex);
alignment.TagData = ReadTestHelper.GetReadCountsTagData(null, 5); // first tag is missing
read = new Read("chr1", alignment);
Assert.False(read.IsDuplex);
alignment.TagData = ReadTestHelper.GetReadCountsTagData(5, 0); // second tag is 0
read = new Read("chr1", alignment);
Assert.False(read.IsDuplex);
alignment.TagData = ReadTestHelper.GetReadCountsTagData(5, null); // second tag is missing
read = new Read("chr1", alignment);
Assert.False(read.IsDuplex);
alignment.TagData = ReadTestHelper.GetReadCountsTagData(0, 0); // both tags 0
read = new Read("chr1", alignment);
Assert.False(read.IsDuplex);
alignment.TagData = ReadTestHelper.GetReadCountsTagData(null, null); // both tags missing
read = new Read("chr1", alignment);
Assert.False(read.IsDuplex);
}
public void AddAndGetCollapsedCount_minQuality(ReadCollapsedType type)
{
int minQuality = 35;
var stateManager = new CollapsedRegionStateManager(false, minQuality);
var readpair = ReadTestHelper.CreateProperReadPair("test", 6, type, pos: 10, matePos: 15, minBaseQuality: 30);
// all base quality less than min quality, no count
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 Reset()
{
var alignment = new BamAlignment
{
Bases = "ACTC",
Position = 5,
MapQuality = 343,
MatePosition = 12312,
Qualities = new[] { (byte)20, (byte)21, (byte)30, (byte)40 },
CigarData = new CigarAlignment("1S3M")
};
alignment.SetIsUnmapped(false);
alignment.SetIsSecondaryAlignment(false);
alignment.SetIsDuplicate(true);
alignment.SetIsProperPair(true);
var read = new Read("chr1", alignment);
read.StitchedCigar = new CigarAlignment("7M");
read.SequencedBaseDirectionMap = new[] { DirectionType.Forward, DirectionType.Reverse, DirectionType.Stitched, DirectionType.Reverse };
alignment.SetIsDuplicate(false);
alignment.MatePosition = 555;
read.Reset("chr2", alignment);
Assert.Equal(556, read.MatePosition);
Assert.False(read.IsPcrDuplicate);
Assert.Equal("chr2", read.Chromosome);
var stitchedCigar = "1S3M1S";
alignment.TagData = ReadTestHelper.GetXCTagData(stitchedCigar);
read.Reset("chr3", alignment);
Assert.Equal(556, read.MatePosition);
Assert.False(read.IsPcrDuplicate);
Assert.Equal("chr3", read.Chromosome);
Assert.Equal(stitchedCigar, read.StitchedCigar.ToString());
}
public void AddAndGetCollapsedCount_AlleleN(ReadCollapsedType type)
{
int minQuality = 20;
var stateManager = new CollapsedRegionStateManager(false, minQuality);
var readpair = ReadTestHelper.CreateProperReadPair("test", 6, type, pos: 10,
matePos: 15, minBaseQuality: 30, candidateBases: "N"); // Generate read pairs only contain "N"
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 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 BamAlignment_Constructor()
{
//Happy Path
var alignment = new BamAlignment
{
AlignmentFlag = 1,
Bases = "AGGGGGGGGTTTTTTCACACACA",
Bin = 3,
CigarData = new CigarAlignment("11M5I9M7D25M"),
FragmentLength = 9,
MapQuality = 50,
MatePosition = 5,
MateRefID = 5,
RefID = 1,
Name = "test",
Position = 11,
TagData = ReadTestHelper.GetXCTagData("11M5I9M7D25M"),
Qualities = new byte[] { 10, 30, 50 },
};
var newAlignment = new BamAlignment(alignment);
Assert.Equal(alignment.AlignmentFlag, newAlignment.AlignmentFlag);
Assert.Equal(alignment.Bases, newAlignment.Bases);
Assert.Equal(alignment.Bin, newAlignment.Bin);
Assert.Equal(alignment.CigarData, newAlignment.CigarData);
Assert.Equal(alignment.FragmentLength, newAlignment.FragmentLength);
Assert.Equal(alignment.MapQuality, newAlignment.MapQuality);
Assert.Equal(alignment.MateRefID, newAlignment.MateRefID);
Assert.Equal(alignment.MatePosition, newAlignment.MatePosition);
Assert.Equal(alignment.RefID, newAlignment.RefID);
Assert.Equal(alignment.Name, newAlignment.Name);
Assert.Equal(alignment.Position, newAlignment.Position);
Assert.Equal(alignment.Qualities, newAlignment.Qualities);
Assert.Equal(alignment.TagData, newAlignment.TagData);
Assert.Equal(alignment.Qualities, newAlignment.Qualities);
}
public void CigarData()
{
var read = ReadTestHelper.CreateRead("chr4", "ACCGACTAAC", 4, new CigarAlignment("10M"));
Verify(new[] { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 }, read.PositionMap.Map);
read = ReadTestHelper.CreateRead("chr4", "ACCGACTAAC", 4, new CigarAlignment("2S1M4I5D2M1S"));
Verify(new[] { -1, -1, 4, -1, -1, -1, -1, 10, 11, -1 }, read.PositionMap.Map);
read = ReadTestHelper.CreateRead("chr1", "ACTTCCCAAAAT", 100, new CigarAlignment("12M"));
for (var i = 0; i < read.PositionMap.Length; i++)
{
Assert.Equal(read.PositionMap.GetPositionAtIndex(i), read.Position + i);
}
read = ReadTestHelper.CreateRead("chr1", "ACTTCCCAAAAT", 100, new CigarAlignment("2S5M4I10D1M"));
Verify(new[]
{
-1, -1, 100, 101, 102, 103, 104, -1, -1, -1, -1, 115
}, read.PositionMap.Map);
Assert.Throws <System.IO.InvalidDataException>(() => ReadTestHelper.CreateRead("chr1", "ACTTCCCAAAAT", 100, new CigarAlignment("100M")));
}
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 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()
{
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 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 TryStitch_MergeReadsSmall()
{
//Migrated from old Pisces: Originally called Pisces_MergeReadsSmall
//test1: happy path
//0 1 2 3 4 5 6 7 8 9
//- C A T A T
//- - - - A T A G G
var read1 = ReadTestHelper.CreateRead("chr1", "CATAT", 1, new CigarAlignment("5M"), new byte[] { 1, 2, 3, 4, 5 }, 4);
StitcherTestHelpers.SetReadDirections(read1, DirectionType.Forward);
var read2 = ReadTestHelper.CreateRead("chr1", "ATAGG", 4, new CigarAlignment("5M"), new byte[] { 1, 20, 30, 40, 50 }, 1);
StitcherTestHelpers.SetReadDirections(read2, DirectionType.Reverse);
var alignmentSet = new AlignmentSet(read1, read2);
var stitcher = StitcherTestHelpers.GetStitcher(10, nifyDisagreements: false);
stitcher.TryStitch(alignmentSet);
TestSuccesfullyStitchedRead(read1, read2, 0, "8M", (mergedRead) =>
{
Assert.Equal(mergedRead.Sequence, "CATATAGG");
StitcherTestHelpers.CompareQuality(new byte[] { 1, 2, 3, 5, 25, 30, 40, 50 }, mergedRead.Qualities);
var expectedDirections = StitcherTestHelpers.BuildDirectionMap(new List <IEnumerable <DirectionType> >
{
StitcherTestHelpers.BuildDirectionSegment(DirectionType.Forward, 3),
StitcherTestHelpers.BuildDirectionSegment(DirectionType.Stitched, 2),
StitcherTestHelpers.BuildDirectionSegment(DirectionType.Reverse, 3)
});
StitcherTestHelpers.VerifyDirectionType(expectedDirections, mergedRead.CigarDirections.Expand().ToArray());
});
//test2: different bases, one with low Q
//0 1 2 3 4 5 6 7 8 9
//- C A T A G
//- - - - A T A G G
read1 = ReadTestHelper.CreateRead("chr1", "CATAG", 1, new CigarAlignment("5M"), new byte[] { 1, 2, 3, 4, 5 }, 4);
StitcherTestHelpers.SetReadDirections(read1, DirectionType.Reverse);
read2 = ReadTestHelper.CreateRead("chr1", "ATAGG", 4, new CigarAlignment("5M"), new byte[] { 1, 20, 30, 40, 50 },
1);
StitcherTestHelpers.SetReadDirections(read2, DirectionType.Forward);
TestSuccesfullyStitchedRead(read1, read2, 10, "8M", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal("CATATAGG", mergedRead.Sequence);
StitcherTestHelpers.CompareQuality(new byte[] { 1, 2, 3, 5, 20, 30, 40, 50 }, mergedRead.Qualities);
var expectedDirections = StitcherTestHelpers.BuildDirectionMap(new List <IEnumerable <DirectionType> >
{
StitcherTestHelpers.BuildDirectionSegment(DirectionType.Reverse, 3),
StitcherTestHelpers.BuildDirectionSegment(DirectionType.Stitched, 2),
StitcherTestHelpers.BuildDirectionSegment(DirectionType.Forward, 3)
});
StitcherTestHelpers.VerifyDirectionType(expectedDirections, mergedRead.CigarDirections.Expand().ToArray());
});
//test3: different bases, both with high Q
//0 1 2 3 4 5 6 7 8 9
//- C A T A G
//- - - - A T A G G
read1 = ReadTestHelper.CreateRead("chr1", "CATAG", 1, new CigarAlignment("5M"), new byte[] { 50, 92, 92, 92, 92 }, 4);
read2 = ReadTestHelper.CreateRead("chr1", "ATAGG", 4, new CigarAlignment("5M"), new byte[] { 2, 20, 30, 40, 50 }, 1);
StitcherTestHelpers.SetReadDirections(read1, DirectionType.Forward);
StitcherTestHelpers.SetReadDirections(read2, DirectionType.Reverse);
TestSuccesfullyStitchedRead(read1, read2, 10, "8M", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal("CATANAGG", mergedRead.Sequence);
StitcherTestHelpers.CompareQuality(new byte[] { 50, 92, 92, 93, 0, 30, 40, 50 }, mergedRead.Qualities);
var expectedDirections = StitcherTestHelpers.BuildDirectionMap(new List <IEnumerable <DirectionType> >
{
StitcherTestHelpers.BuildDirectionSegment(DirectionType.Forward, 3),
StitcherTestHelpers.BuildDirectionSegment(DirectionType.Stitched, 2),
StitcherTestHelpers.BuildDirectionSegment(DirectionType.Reverse, 3)
});
StitcherTestHelpers.VerifyDirectionType(expectedDirections, mergedRead.CigarDirections.Expand().ToArray());
}, nifyDisagreements: true);
}
//[Fact] //TODO
//This is currently expected to fail.
//Because we now allow to stitch between softclips.
//We should adjust this this unit test, or otherwise clarify the expectation.
public void Pisces_MergeReadsWithInsertion_BoundaryTests()
{
//Migrated from old Pisces: Originally called Pisces_MergeReadsWithInsertion_BoundaryTests
// insertion at edge of read
//0 1 2 3 - - - 4 5 6 7 8 9
//- C A T A T A G G
//- - - - A T A G G T A A
var read1 = ReadTestHelper.CreateRead("chr1",
"CATATAGG",
1,
new CigarAlignment("3M3I2M"),
new byte[8],
4);
var read2 = ReadTestHelper.CreateRead("chr1",
"ATAGGTAA",
4,
new CigarAlignment("3S5M"),
new byte[8],
1);
TestSuccesfullyStitchedRead(read1, read2, 0, "3M3I5M", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal(mergedRead.Sequence, "CATATAGGTAA");
});
//0 1 2 3 - - - 4 5 6 7 8 9
//- C A T A T A G G
//- - - - - T A G G T A A
read1 = ReadTestHelper.CreateRead("chr1", "CATATAGG", 1, new CigarAlignment("3M3I2M"),
new byte[8], 4);
read2 = ReadTestHelper.CreateRead("chr1", "TAGGTAA", 4, new CigarAlignment("2S5M"),
new byte[8], 1);
TestSuccesfullyStitchedRead(read1, read2, 0, "3M3I5M", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal(mergedRead.Sequence, "CATATAGGTAA");
});
// TODO - Currently, we are allowing stitching over softclips. Should we really disallow this?
// TJD: Yes. But lets explictly turn of "usesoftclippedreads" for this test.
// GB: I am now having trouble understanding why stitching should fail here. I believe UseSoftclippedReads just refers to whether the softclips can contribute to direction.
//0 1 2 3 - - - 4 5 6 7 8 9
//- C A T A T A G G
//- - - - - T A G G T A A -- Looks like this if we knew it was an insertion...
//- - T A G G T A A -- Really looks like this...
read1 = ReadTestHelper.CreateRead("chr1", "CATATAGG", 1, new CigarAlignment("3M5S"),
new byte[8], 4);
read2 = ReadTestHelper.CreateRead("chr1", "TAGGTAA", 4, new CigarAlignment("2S5M"),
new byte[8], 1);
// Allow using softclipped bases: should take the CAT and the GGTAA
TestSuccesfullyStitchedRead(read1, read2, 0, "8M", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal("1F7S", mergedRead.CigarDirections.ToString());
Assert.Equal("CATATAGG", mergedRead.Sequence); // For stitched sites (all but the first), if disagreement, takes R1's
});
// Allow using softclipped bases and nifying: should take the C and the rest are Ns
TestSuccesfullyStitchedRead(read1, read2, 0, "8M", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal("1F7S", mergedRead.CigarDirections.ToString());
Assert.Equal("CNNNNNNN", mergedRead.Sequence); // For stitched sites (all but the first), if disagreement, takes R1's
}, nifyDisagreements: true);
// Not using softclipped bases: should take the first 3 from R1 and rest from R2.
TestSuccesfullyStitchedRead(read1, read2, 0, "8M", (mergedRead) =>
{
Assert.NotNull(mergedRead);
Assert.Equal("3F5R", mergedRead.CigarDirections.ToString());
Assert.Equal("CATGGTAA", mergedRead.Sequence); // No stitched sites. Just take R1 first 3 and R2 for the last 5
}, useSoftclippedBases: false);
//StitcherTestHelpers.TestUnstitchableReads(read1, read2, 0, (unStitchableReads) =>
//{
// Assert.Equal(1, unStitchableReads.Count(x => StitcherTestHelpers.VerifyReadsEqual(read1, x)));
// Assert.Equal(1, unStitchableReads.Count(x => StitcherTestHelpers.VerifyReadsEqual(read2, x)));
//},
//false);
}
public void TryStitchHomopolymer()
{
// Simple test, test indexing accuracy, shouldn't stitch
// GTTTCCCAGCATGCAGTAAAAAAAAAAAAAA
// AAAAAAAAAAAAAAGCATGACGGAATTGACAG
var readA1 = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTAAAAAAAAAAAAAA", 100, new CigarAlignment("31M"), null, 117, 30, false, 30);
var readA2 = ReadTestHelper.CreateRead("chr1", "AAAAAAAAAAAAAAGCATGACGGAATTGACAG", 117, new CigarAlignment("32M"), null, 100, 30, false, 30);
var mergedReadA = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTAAAAAAAAAAAAAAGCATGACGGAATTGACAG", 100, new CigarAlignment("49M"), null);
//mergedReadA.CigarDirections = new CigarDirection("16F13S17R");
TestHomoPolymerScenario(readA1, readA2, mergedReadA, false, false);
// Simple test, test indexing accuracy, should stitch
// GTTTCCCAGCATGCAGTAAAAAAAAAAAAAAG
// AAAAAAAAAAAAAAGCATGACGGAATTGACAG
var readB1 = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTAAAAAAAAAAAAAAG", 100, new CigarAlignment("32M"), null, 117, 30, false, 30);
var readB2 = ReadTestHelper.CreateRead("chr1", "AAAAAAAAAAAAAAGCATGACGGAATTGACAG", 117, new CigarAlignment("32M"), null, 100, 30, false, 30);
var mergedReadB = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTAAAAAAAAAAAAAAGCATGACGGAATTGACAG", 100, new CigarAlignment("49M"), null);
TestHomoPolymerScenario(readB1, readB2, mergedReadB, false, true);
//// Same start location, different softclipping weirdness, shouldn't stitch
//// gttttacAAAAAAAAAGGTGCAGATCAGGTT
//// GTTTTACAAAAAAAAAggtgcagatcaggtt
var readC1 = ReadTestHelper.CreateRead("chr1", "GTTTTACAAAAAAAAAGGTGCAGATCAGGTT", 107, new CigarAlignment("7S24M"), null, 100, 30, false, 30);
var readC2 = ReadTestHelper.CreateRead("chr1", "GTTTTACAAAAAAAAAGGTGCAGATCAGGTT", 100, new CigarAlignment("16M15S"), null, 107, 30, false, 30);
var mergedReadC = ReadTestHelper.CreateRead("chr1", "GTTTTACAAAAAAAAAGGTGCAGATCAGGTT", 100, new CigarAlignment("31M"), null);
TestHomoPolymerScenario(readC1, readC2, mergedReadC, false, false);
//// Same as C, but less soft clipping so anchor present in overlap, should stitch
//// gttttaCAAAAAAAAAGGTGCAGATCAGGTT
//// GTTTTACAAAAAAAAAggtgcagatcaggtt
var readD1 = ReadTestHelper.CreateRead("chr1", "GTTTTACAAAAAAAAAGGTGCAGATCAGGTT", 106, new CigarAlignment("6S25M"), null, 100, 30, false, 30);
var readD2 = ReadTestHelper.CreateRead("chr1", "GTTTTACAAAAAAAAAGGTGCAGATCAGGTT", 100, new CigarAlignment("16M15S"), null, 106, 30, false, 30);
var mergedReadD = ReadTestHelper.CreateRead("chr1", "GTTTTACAAAAAAAAAGGTGCAGATCAGGTT", 100, new CigarAlignment("31M"), null);
TestHomoPolymerScenario(readD1, readD2, mergedReadD, false, true);
//// Dinucleotide repeats (AT x 7); should not stitch
//// GTTTCCCAGCATGCAGTATATATATATATAT
//// ATATATATATATATGCATGACGGAATTGACAG
var readE1 = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTATATATATATATAT", 100, new CigarAlignment("31M"), null, 117, 30, false, 30);
var readE2 = ReadTestHelper.CreateRead("chr1", "ATATATATATATATGCATGACGGAATTGACAG", 117, new CigarAlignment("32M"), null, 100, 30, false, 30);
var mergedReadE = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTATATATATATATATGCATGACGGAATTGACAG", 100, new CigarAlignment("49M"), null);
TestHomoPolymerScenario(readE1, readE2, mergedReadE, false, false);
//// Dinucleotide repeat incomplete; should not stitch (AT x 6 + A)
//// GTTTCCCAGCATGCAGTATATATATATATA
//// ATATATATATATAGCATGACGGAATTGACAG
var readF1 = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTATATATATATATA", 100, new CigarAlignment("30M"), null, 117, 30, false, 30);
var readF2 = ReadTestHelper.CreateRead("chr1", "ATATATATATATAGCATGACGGAATTGACAG", 117, new CigarAlignment("31M"), null, 100, 30, false, 30);
var mergedReadF = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTATATATATATATAGCATGACGGAATTGACAG", 100, new CigarAlignment("48M"), null);
TestHomoPolymerScenario(readF1, readF2, mergedReadF, false, false);
//// Overlap only 3bp long, should stitch
//// GTTTCCCAGCATGCAGTATA
//// ATATATGACGGAATTGACAG
var readG1 = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTATA", 100, new CigarAlignment("20M"), null, 117, 30, false, 30);
var readG2 = ReadTestHelper.CreateRead("chr1", "ATATATGACGGAATTGACAG", 117, new CigarAlignment("20M"), null, 100, 30, false, 30);
var mergedReadG = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTATATATGACGGAATTGACAG", 100, new CigarAlignment("37M"), null);
TestHomoPolymerScenario(readG1, readG2, mergedReadG, false, true);
//// Overlap 4bp long, should not stitch (AT repeat)
//// GTTTCCCAGCATGCAGTATAT
//// ATATATGACGGAATTGACAG
var readH1 = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTATAT", 100, new CigarAlignment("21M"), null, 117, 30, false, 30);
var readH2 = ReadTestHelper.CreateRead("chr1", "ATATATGACGGAATTGACAG", 117, new CigarAlignment("20M"), null, 100, 30, false, 30);
var mergedReadH = ReadTestHelper.CreateRead("chr1", "GTTTCCCAGCATGCAGTATATATGACGGAATTGACAG", 100, new CigarAlignment("37M"), null);
TestHomoPolymerScenario(readH1, readH2, mergedReadH, false, false);
}
private MockFactoryWithDefaults GetMockedFlowFactory(int numIterations)
{
var currentIteration = 0;
var factory = new MockFactoryWithDefaults(new PiscesApplicationOptions());
// alignment source
var mockAlignmentSource = new Mock <IAlignmentSource>();
mockAlignmentSource.Setup(s => s.GetNextRead()).Returns(() =>
currentIteration < numIterations ? ReadTestHelper.CreateRead(_chrReference.Name, "AAA", 1 + currentIteration++) : null);
mockAlignmentSource.Setup(s => s.LastClearedPosition).Returns(() => currentIteration);
factory.MockAlignmentSource = mockAlignmentSource;
// state manager
_candidateList = new List <CandidateAllele>()
{
new CandidateAllele("chr1", 100, "A", "G", AlleleCategory.Snv)
};
_batch = new CandidateBatch(_candidateList);
var mockStateManager = new Mock <IStateManager>();
mockStateManager.Setup(s => s.GetCandidatesToProcess(It.IsAny <int?>(), _chrReference, It.IsAny <HashSet <Tuple <string, int, string, string> > >())).Returns(_batch);
factory.MockStateManager = mockStateManager;
// variant finder
var mockVariantFinder = new Mock <ICandidateVariantFinder>();
mockVariantFinder.Setup(v => v.FindCandidates(It.IsAny <Read>(), _chrReference.Sequence, _chrReference.Name)).Returns(_candidateList);
factory.MockVariantFinder = mockVariantFinder;
// variant caller
var mockVariantCaller = new Mock <IAlleleCaller>();
mockVariantCaller.Setup(v => v.Call(_batch, mockStateManager.Object)).Returns(_calledList);
factory.MockVariantCaller = mockVariantCaller;
// region mapper
var mockRegionMapper = new Mock <IRegionMapper>();
factory.MockRegionMapper = mockRegionMapper;
return(factory);
}
public static Read CreateRead(string cigarString, string bases, byte[] readQualities, int readStartPos)
{
var read = ReadTestHelper.CreateRead("chr1", bases, readStartPos, new CigarAlignment(cigarString), readQualities);
return(read);
}
