public void LastPositionIsNotMatch()
{
var nbhd = new VcfNeighborhood(new VariantCallingParameters(), 0, "chr1", new VariantSite(120), new VariantSite(121), "T");
var variantSite = new VariantSite(123);
nbhd.AddVariantSite(variantSite, "ATCG");
var vsPositionMatch = new VariantSite(123);
Assert.False(nbhd.LastPositionIsNotMatch(vsPositionMatch));
var vsPositionMismatch = new VariantSite(124);
Assert.True(nbhd.LastPositionIsNotMatch(vsPositionMismatch));
}
public void LastPositionIsNotMatch()
{
var nbhd = new VcfNeighborhood(0, "chr1", new VariantSite(120), new VariantSite(121));
var variantSite = new VariantSite(123);
nbhd.AddVariantSite(variantSite);
var vsPositionMatch = new VariantSite(123);
Assert.False(nbhd.LastPositionIsNotMatch(vsPositionMatch));
var vsPositionMismatch = new VariantSite(124);
Assert.True(nbhd.LastPositionIsNotMatch(vsPositionMismatch));
}
public void AddVariantSite()
{
var nbhd = new VcfNeighborhood(0, "chr1", new VariantSite(120)
{
VcfReferenceAllele = "A"
}, new VariantSite(121));
Assert.Equal("NbhdNum0_chr1_120", nbhd.Id);
var variantSite = new VariantSite(123);
nbhd.AddVariantSite(variantSite);
Assert.Equal(3, nbhd.VcfVariantSites.Count);
Assert.Equal("NbhdNum0_chr1_120", nbhd.Id);
}
public void AddVariantSite()
{
var nbhd = new VcfNeighborhood(new VariantCallingParameters(), 0, "chr1", new VariantSite(120)
{
VcfReferenceAllele = "A"
}, new VariantSite(121), "T");
Assert.Equal("NbhdNum0_chr1_120", nbhd.Id);
var variantSite = new VariantSite(123);
nbhd.AddVariantSite(variantSite, "ATCG");
Assert.Equal("ATATCG", nbhd.ReferenceSequence);
Assert.Equal(3, nbhd.VcfVariantSites.Count);
Assert.Equal("NbhdNum0_chr1_120", nbhd.Id);
}
public void CallAVariantInANewLocation()
{
//set up the original variants
var originalVcfVariant1 = TestHelper.CreateDummyAllele("chr1", 123, "A", "T", 1000, 156);
var originalVcfVariant2 = TestHelper.CreateDummyAllele("chr1", 124, "A", "T", 1000, 156);
var originalVcfVariant3 = TestHelper.CreateDummyAllele("chr1", 234, "A", "T", 1000, 156);
var originalVcfVariant4 = TestHelper.CreateDummyAllele("chr1", 234, "A", "T", 1000, 156);
var vs1 = new VariantSite(originalVcfVariant1);
var vs2 = new VariantSite(originalVcfVariant2);
var vs3 = new VariantSite(originalVcfVariant3);
var vs4 = new VariantSite(originalVcfVariant4);
var vcParams = new VariantCallingParameters();
vcParams.Validate();
var caller = new VariantCaller(vcParams, new BamFilterParameters());
var nbhd = new VcfNeighborhood(vcParams, 0, "chr1", vs1, vs2, "");
nbhd.AddVariantSite(vs3, "RRRRR"); //note, we do not add vs4, that is not going to get used for phasing. Sps it is a variant that failed filters.
nbhd.SetRangeOfInterest();
//now stage one candidate MNV:
var newMNV = new CalledAllele(AlleleCategory.Snv)
{
Chromosome = "chr1",
ReferencePosition = 129,
ReferenceAllele = "A",
AlternateAllele = "TT",
VariantQscore = 100,
TotalCoverage = 1000,
AlleleSupport = 500
};
nbhd.AddAcceptedPhasedVariant(newMNV);
var suckedUpRefRecord1000 = new SuckedUpRefRecord()
{
Counts = 1000, AlleleThatClaimedIt = new CalledAllele()
};
nbhd.UsedRefCountsLookup = new Dictionary <int, SuckedUpRefRecord>()
{
{ 124, suckedUpRefRecord1000 }
};
caller.CallMNVs(nbhd);
caller.CallRefs(nbhd);
var acceptedMNVs = nbhd.CalledVariants;
var acceptedRefs = nbhd.CalledRefs;
var vcfVariant0asRef = new VcfVariant()
{
ReferenceName = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
VariantAlleles = new[] { "." },
Genotypes = new List <Dictionary <string, string> >()
{
new Dictionary <string, string>()
{
{ "GT", "0/." }
}
},
};
var vcfVariant3asRef = new VcfVariant()
{
ReferenceName = "chr1",
ReferencePosition = 234,
ReferenceAllele = "A",
VariantAlleles = new[] { "." },
Genotypes = new List <Dictionary <string, string> >()
{
new Dictionary <string, string>()
{
{ "GT", "0/." }
}
},
};
var vcfVariant2asNull = new VcfVariant()
{
ReferenceName = "chr1",
ReferencePosition = 124,
ReferenceAllele = "A",
VariantAlleles = new[] { "." },
Genotypes = new List <Dictionary <string, string> >()
{
new Dictionary <string, string>()
{
{ "GT", "./." }
}
},
};
Assert.Equal(1, acceptedMNVs.Count);
Assert.Equal(1, acceptedMNVs[129].Count);
Assert.Equal(3, acceptedRefs.Count);
VcfMergerTests.CheckVariantsMatch(vcfVariant0asRef, acceptedRefs[123]);
VcfMergerTests.CheckVariantsMatch(vcfVariant2asNull, acceptedRefs[124]);
VcfMergerTests.CheckVariantsMatch(newMNV, acceptedMNVs[129][0]);
VcfMergerTests.CheckVariantsMatch(vcfVariant3asRef, acceptedRefs[234]);
}
public void SortSites()
{
var nbhd = new VcfNeighborhood(new VariantCallingParameters(), 0, "chr1", new VariantSite(120)
{
VcfReferenceAllele = "A"
}, new VariantSite(121), "T");
var variantSite1 = new VariantSite(123);
variantSite1.VcfReferencePosition = 140453137;
variantSite1.VcfReferenceAllele = "C";
variantSite1.VcfAlternateAllele = "CGTA";
variantSite1.OriginalAlleleFromVcf = new Pisces.Domain.Models.Alleles.CalledAllele()
{
ReferencePosition = 7
};
nbhd.AddVariantSite(variantSite1, "ATCG");
var variantSite2 = new VariantSite();
variantSite2.VcfReferencePosition = 140453137;
variantSite2.VcfReferenceAllele = "C";
variantSite2.VcfAlternateAllele = "T";
variantSite2.OriginalAlleleFromVcf = new Pisces.Domain.Models.Alleles.CalledAllele()
{
ReferencePosition = 8
};
nbhd.AddVariantSite(variantSite2, "");
var variantSite3 = new VariantSite();
variantSite3.VcfReferencePosition = 140453130;
variantSite3.VcfReferenceAllele = "C";
variantSite3.VcfAlternateAllele = "T";
variantSite3.OriginalAlleleFromVcf = new Pisces.Domain.Models.Alleles.CalledAllele()
{
ReferencePosition = 9
};
nbhd.AddVariantSite(variantSite3, "");
Assert.Equal(5, nbhd.VcfVariantSites.Count);
Assert.Equal(120, nbhd.VcfVariantSites[0].VcfReferencePosition);
Assert.Equal(120, nbhd.VcfVariantSites[0].TrueFirstBaseOfDiff);
Assert.Equal("A", nbhd.VcfVariantSites[0].VcfReferenceAllele);
Assert.Equal("N", nbhd.VcfVariantSites[0].VcfAlternateAllele);
Assert.Equal(121, nbhd.VcfVariantSites[1].VcfReferencePosition);
Assert.Equal(121, nbhd.VcfVariantSites[1].TrueFirstBaseOfDiff);
Assert.Equal("N", nbhd.VcfVariantSites[1].VcfReferenceAllele);
Assert.Equal("N", nbhd.VcfVariantSites[1].VcfAlternateAllele);
Assert.Equal(140453137, nbhd.VcfVariantSites[2].VcfReferencePosition);
Assert.Equal(140453138, nbhd.VcfVariantSites[2].TrueFirstBaseOfDiff);
Assert.Equal("C", nbhd.VcfVariantSites[2].VcfReferenceAllele);
Assert.Equal("CGTA", nbhd.VcfVariantSites[2].VcfAlternateAllele);
Assert.Equal(140453137, nbhd.VcfVariantSites[3].VcfReferencePosition);
Assert.Equal(140453137, nbhd.VcfVariantSites[3].TrueFirstBaseOfDiff);
Assert.Equal("C", nbhd.VcfVariantSites[3].VcfReferenceAllele);
Assert.Equal("T", nbhd.VcfVariantSites[3].VcfAlternateAllele);
Assert.Equal(140453130, nbhd.VcfVariantSites[4].VcfReferencePosition);
Assert.Equal(140453130, nbhd.VcfVariantSites[4].TrueFirstBaseOfDiff);
Assert.Equal("C", nbhd.VcfVariantSites[4].VcfReferenceAllele);
Assert.Equal("T", nbhd.VcfVariantSites[4].VcfAlternateAllele);
nbhd.OrderVariantSitesByFirstTrueStartPosition();
Assert.Equal(120, nbhd.VcfVariantSites[0].VcfReferencePosition);
Assert.Equal(120, nbhd.VcfVariantSites[0].TrueFirstBaseOfDiff);
Assert.Equal("A", nbhd.VcfVariantSites[0].VcfReferenceAllele);
Assert.Equal("N", nbhd.VcfVariantSites[0].VcfAlternateAllele);
Assert.Equal(121, nbhd.VcfVariantSites[1].VcfReferencePosition);
Assert.Equal(121, nbhd.VcfVariantSites[1].TrueFirstBaseOfDiff);
Assert.Equal("N", nbhd.VcfVariantSites[1].VcfReferenceAllele);
Assert.Equal("N", nbhd.VcfVariantSites[1].VcfAlternateAllele);
Assert.Equal(140453130, nbhd.VcfVariantSites[2].VcfReferencePosition);
Assert.Equal(140453130, nbhd.VcfVariantSites[2].TrueFirstBaseOfDiff);
Assert.Equal("C", nbhd.VcfVariantSites[2].VcfReferenceAllele);
Assert.Equal("T", nbhd.VcfVariantSites[2].VcfAlternateAllele);
Assert.Equal(7, nbhd.VcfVariantSites[2].OriginalAlleleFromVcf.ReferencePosition);
Assert.Equal(140453137, nbhd.VcfVariantSites[3].VcfReferencePosition);
Assert.Equal(140453137, nbhd.VcfVariantSites[3].TrueFirstBaseOfDiff);
Assert.Equal("C", nbhd.VcfVariantSites[3].VcfReferenceAllele);
Assert.Equal("T", nbhd.VcfVariantSites[3].VcfAlternateAllele);
Assert.Equal(8, nbhd.VcfVariantSites[3].OriginalAlleleFromVcf.ReferencePosition);
Assert.Equal(140453137, nbhd.VcfVariantSites[4].VcfReferencePosition);
Assert.Equal(140453138, nbhd.VcfVariantSites[4].TrueFirstBaseOfDiff);
Assert.Equal("C", nbhd.VcfVariantSites[4].VcfReferenceAllele);
Assert.Equal("CGTA", nbhd.VcfVariantSites[4].VcfAlternateAllele);
Assert.Equal(9, nbhd.VcfVariantSites[4].OriginalAlleleFromVcf.ReferencePosition);
}
public void GetMergedListOfVariants_LeaveUntouchedAsIs()
{
//chr7 55242464 . A G 6 LowSupport DP=287 GT:GQ:AD:DP:VF:NL:SB:NC:US:AQ:LQ 0/1:6:286,1:287:0.00348:30:-7.4908:0.0304:0,0,0,0,0,1,56,17,49,56,69,40:4.294:0.000
//chr7 55242464 . AGGAATTAAGAGAAGC A 100 PASS DP=298 GT:GQ:AD:DP:VF:NL:SB:NC:US:AQ:LQ 0/1:100:284,14:298:0.04698:30:-75.6792:0.0000:1,0,1,4,5,3,58,18,49,55,71,41:100.000:100.000
//chr7 55242481 . A T 6 LowSupport DP=306 GT:GQ:AD:DP:VF:NL:SB:NC:US:AQ:LQ 0/1:6:305,1:306:0.00327:30:-7.4622:0.0556:0,0,0,0,0,1,63,20,54,52,69,48:3.669:0.000
//chr7 55242487 . C T 6 LowSupport DP=325 GT:GQ:AD:DP:VF:NL:SB:NC:US:AQ:LQ 0/1:6:324,1:325:0.00308:30:-7.1283:0.0469:0,0,0,1,0,0,67,24,61,53,68,52:1.954:0.000
//chr7 55242489 . G T 6 LowSupport DP=327 GT:GQ:AD:DP:VF:NL:SB:NC:US:AQ:LQ 0/1:6:326,1:327:0.00306:30:-7.0226:0.0411:0,0,1,0,0,0,71,23,60,54,67,52:2.177:0.000
var originalVcfVariant1 = TestHelper.CreateDummyAllele("chr7", 55242464, "A", "G", 287, 1);
originalVcfVariant1.ReferenceSupport = 286;
var originalVcfVariant2 = TestHelper.CreateDummyAllele("chr2", 55242464, "AGGAATTAAGAGAAGC", "A", 298, 14);
originalVcfVariant2.ReferenceSupport = 284;
var originalVcfVariant3 = TestHelper.CreateDummyAllele("chr7", 55242481, "A", "T", 306, 1);
originalVcfVariant3.ReferenceSupport = 305;
var originalVcfVariant4 = TestHelper.CreateDummyAllele("chr7", 55242487, "C", "T", 325, 1);
originalVcfVariant4.ReferenceSupport = 324;
var originalVcfVariant5 = TestHelper.CreateDummyAllele("chr7", 55242489, "G", "T", 327, 1);
originalVcfVariant5.ReferenceSupport = 326;
//#2mnv accepted: chr7 55242464 . AGGAATTAAGAGAAGC A
//chr7 55242464 . AGGAATTAAGAGAAGC A 100 PASS DP=286 GT:GQ:AD:DP:VF:NL:SB:NC:US 0/1:100:272,13:286:0.04545:30:-100.0000:0.3024:0,0,0,0,0,0,0,0,0,0,0,0
//#3mnv accepted: chr7 55242464 . AGGAATTAAGAGAAGCAA GAT.
//chr7 55242464 . AGGAATTAAGAGAAGCAA GAT 6 PASS DP=293 GT:GQ:AD:DP:VF:NL:SB:NC:US 0/1:6:226,1:293:0.00341:30:-100.0000:0.2854:0,0,0,0,0,0,0,0,0,0,0,0
var mnv1 = TestHelper.CreateDummyAllele("chr7", 55242464, "AGGAATTAAGAGAAGC", "A", 286, 13);
mnv1.ReferenceSupport = 272;
var mnv2 = TestHelper.CreateDummyAllele("chr7", 55242464, "AGGAATTAAGAGAAGCAA", "GAT", 293, 1);
mnv2.ReferenceSupport = 226;
//#4mnv accepted: chr7 55242487 . C T.
var mnv3 = TestHelper.CreateDummyAllele("chr7", 55242487, "C", "T", 325, 1);
mnv3.ReferenceSupport = 324;
//#5mnv accepted: chr7 55242489 . G T.
var mnv4 = TestHelper.CreateDummyAllele("chr7", 55242489, "G", "T", 327, 1);
mnv4.ReferenceSupport = 326;
var vs1 = new VariantSite((originalVcfVariant1));
var vs2 = new VariantSite((originalVcfVariant2));
var vs3 = new VariantSite((originalVcfVariant3));
var vs4 = new VariantSite((originalVcfVariant4));
var vs5 = new VariantSite((originalVcfVariant5));
var nbhd1 = new VcfNeighborhood(0, "chr7", vs1, vs2);
nbhd1.AddVariantSite(vs3);
nbhd1.AddVariantSite(vs4);
nbhd1.AddVariantSite(vs5);
var calledNbhd = new CallableNeighborhood(nbhd1, new VariantCallingParameters());
calledNbhd.CalledVariants = new Dictionary <int, List <CalledAllele> > {
{ mnv1.ReferencePosition, new List <CalledAllele>()
{
mnv1, mnv2
} },
{ mnv3.ReferencePosition, new List <CalledAllele>()
{
mnv3
} },
{ mnv4.ReferencePosition, new List <CalledAllele>()
{
mnv4
} },
};
//Became ref
//chr7 55242481 . A . 100 PASS DP=306 GT:GQ:AD:DP:VF:NL:SB:NC:US 0/.:100:305:306:0.00327:30:-100.0000:0.0556:0,0,0,0,0,0,0,0,0,0,0,0
var var3AsRef = TestHelper.CreateDummyAllele("chr7", 55242481, "A", ".", 306, 0);
calledNbhd.CalledRefs = new Dictionary <int, CalledAllele>()
{
{ var3AsRef.ReferencePosition, var3AsRef }
};
var origAlleles = new List <Tuple <CalledAllele, string> >();
origAlleles.Add(new Tuple <CalledAllele, string>(originalVcfVariant1, "Variant1"));
origAlleles.Add(new Tuple <CalledAllele, string>(originalVcfVariant2, "Variant2"));
origAlleles.Add(new Tuple <CalledAllele, string>(originalVcfVariant3, "Variant3"));
origAlleles.Add(new Tuple <CalledAllele, string>(originalVcfVariant4, "Variant4"));
origAlleles.Add(new Tuple <CalledAllele, string>(originalVcfVariant5, "Variant5"));
var mergedList = VcfMerger.GetMergedListOfVariants(calledNbhd, origAlleles);
Assert.Equal(5, mergedList.Count);
// Anything that is new from phasing (real MNV, ref conversion) should have empty string portion of the tuple.
Assert.Equal(3, mergedList.Count(x => x.Item2 == ""));
// Variant4 and 5 should be retained as-is because after being spat out of phasing nothing has changed in terms of allele, ref support, allele support, or coverage
Assert.Equal(1, mergedList.Count(x => x.Item2 == "Variant4"));
Assert.Equal(1, mergedList.Count(x => x.Item2 == "Variant5"));
//Should take new one if anything is changed
// Pretend mnv3 had a ref base sucked up by other MNV
mnv3.ReferenceSupport = originalVcfVariant4.ReferenceSupport - 1;
calledNbhd.CalledVariants = new Dictionary <int, List <CalledAllele> > {
{ mnv1.ReferencePosition, new List <CalledAllele>()
{
mnv1, mnv2
} },
{ mnv3.ReferencePosition, new List <CalledAllele>()
{
mnv3
} },
{ mnv4.ReferencePosition, new List <CalledAllele>()
{
mnv4
} },
};
mergedList = VcfMerger.GetMergedListOfVariants(calledNbhd, origAlleles);
Assert.Equal(5, mergedList.Count);
// Anything that is new from phasing (real MNV, ref conversion) should have empty string portion of the tuple.
Assert.Equal(4, mergedList.Count(x => x.Item2 == ""));
// Only Variant5 should be retained as-is because after being spat out of phasing nothing has changed in terms of allele, ref support, allele support, or coverage
// Variant 4 has changed in terms of ref support.
Assert.Equal(0, mergedList.Count(x => x.Item2 == "Variant4"));
Assert.Equal(1, mergedList.Count(x => x.Item2 == "Variant5"));
// Pretend mnv3 had coverage changed (not sure this is realistic, but to cover all bases adding test)
mnv3.ReferenceSupport = originalVcfVariant4.ReferenceSupport;
mnv3.TotalCoverage = originalVcfVariant4.TotalCoverage - 1;
calledNbhd.CalledVariants = new Dictionary <int, List <CalledAllele> > {
{ mnv1.ReferencePosition, new List <CalledAllele>()
{
mnv1, mnv2
} },
{ mnv3.ReferencePosition, new List <CalledAllele>()
{
mnv3
} },
{ mnv4.ReferencePosition, new List <CalledAllele>()
{
mnv4
} },
};
mergedList = VcfMerger.GetMergedListOfVariants(calledNbhd, origAlleles);
Assert.Equal(5, mergedList.Count);
// Anything that is new from phasing (real MNV, ref conversion) should have empty string portion of the tuple.
Assert.Equal(4, mergedList.Count(x => x.Item2 == ""));
// Only Variant5 should be retained as-is because after being spat out of phasing nothing has changed in terms of allele, ref support, allele support, or coverage
// Variant 4 has changed in terms of ref support.
Assert.Equal(0, mergedList.Count(x => x.Item2 == "Variant4"));
Assert.Equal(1, mergedList.Count(x => x.Item2 == "Variant5"));
// Pretend mnv3 had allele support changed (not sure this is realistic, but to cover all bases adding test)
mnv3.TotalCoverage = originalVcfVariant4.TotalCoverage;
mnv3.AlleleSupport = originalVcfVariant4.AlleleSupport - 1;
calledNbhd.CalledVariants = new Dictionary <int, List <CalledAllele> > {
{ mnv1.ReferencePosition, new List <CalledAllele>()
{
mnv1, mnv2
} },
{ mnv3.ReferencePosition, new List <CalledAllele>()
{
mnv3
} },
{ mnv4.ReferencePosition, new List <CalledAllele>()
{
mnv4
} },
};
mergedList = VcfMerger.GetMergedListOfVariants(calledNbhd, origAlleles);
Assert.Equal(5, mergedList.Count);
// Anything that is new from phasing (real MNV, ref conversion) should have empty string portion of the tuple.
Assert.Equal(4, mergedList.Count(x => x.Item2 == ""));
// Only Variant5 should be retained as-is because after being spat out of phasing nothing has changed in terms of allele, ref support, allele support, or coverage
// Variant 4 has changed in terms of ref support.
Assert.Equal(0, mergedList.Count(x => x.Item2 == "Variant4"));
Assert.Equal(1, mergedList.Count(x => x.Item2 == "Variant5"));
}
