public void GetNeighborhoods()
{
var variant = CreateVariant(123);
var secondVariant = CreateVariant(124);
var thirdVariant = CreateVariant(125);
var fourthVariant = CreateVariant(128);
var fifthVariant = CreateVariant(129);
var thirdVariantFailing = CreateVariant(125);
thirdVariantFailing.Filters = "LowQ";
// -------------------------------------------------
// Add two variants that should be chained together
// - When there are no neighborhoods
// - When there is a neighborhood that they can join
// - When there are neighborhoods available but they cannot join
// -------------------------------------------------
var neighborhoodManager = CreateBuilder(new List <VcfVariant>());
Assert.Equal(0, neighborhoodManager.GetNeighborhoods().Count());
neighborhoodManager = CreateBuilder(new List <VcfVariant>
{
variant,
secondVariant
});
var neighborhoods = neighborhoodManager.GetNeighborhoods();
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant
}, neighborhoods.First());
neighborhoodManager = CreateBuilder(new List <VcfVariant>()
{
variant, secondVariant, thirdVariant
});
neighborhoods = neighborhoodManager.GetNeighborhoods();
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, thirdVariant
}, neighborhoods.First());
neighborhoodManager = CreateBuilder(new List <VcfVariant>()
{
variant, secondVariant, thirdVariant, fourthVariant, fifthVariant
});
neighborhoods = neighborhoodManager.GetNeighborhoods();
Assert.Equal(2, neighborhoods.Count());
var neighborhood1 = neighborhoods.Last();
Assert.True(neighborhood1.HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, thirdVariant
}, neighborhoods.First());
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
fourthVariant, fifthVariant
}, neighborhood1);
// Different phasing distance
neighborhoodManager = CreateBuilder(new List <VcfVariant> {
variant, secondVariant, fourthVariant, fifthVariant
}, 5);
neighborhoods = neighborhoodManager.GetNeighborhoods();
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, fourthVariant, fifthVariant
}, neighborhoods.First());
// -------------------------------------------------
// Passing/Failing Variants Allowed
// -------------------------------------------------
// Passing Only
neighborhoodManager = CreateBuilder(new List <VcfVariant> {
variant, secondVariant, thirdVariantFailing, fourthVariant, fifthVariant
});
neighborhoods = neighborhoodManager.GetNeighborhoods();
Assert.Equal(2, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant
}, neighborhoods.First());
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
fourthVariant, fifthVariant
}, neighborhoods.Last());
// Passing Only, Larger phasing distance
neighborhoodManager = CreateBuilder(new List <VcfVariant> {
variant, secondVariant, thirdVariantFailing, fourthVariant, fifthVariant
}, 5);
neighborhoods = neighborhoodManager.GetNeighborhoods();
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, fourthVariant, fifthVariant
}, neighborhoods.First());
// Passing Only = false
neighborhoodManager = CreateBuilder(new List <VcfVariant> {
variant, secondVariant, thirdVariantFailing, fourthVariant, fifthVariant
}, passingOnly: false);
neighborhoods = neighborhoodManager.GetNeighborhoods();
Assert.Equal(2, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, thirdVariantFailing
}, neighborhoods.First());
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
fourthVariant, fifthVariant
}, neighborhoods.Last());
// Passing Only = false, Larger phasing distance
neighborhoodManager = CreateBuilder(new List <VcfVariant> {
variant, secondVariant, thirdVariantFailing, fourthVariant, fifthVariant
}, 5, false);
neighborhoods = neighborhoodManager.GetNeighborhoods();
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, thirdVariantFailing, fourthVariant, fifthVariant
}, neighborhoods.First());
}
public void GetNeighborhoods()
{
var variant = CreateVariant(123);
var secondVariant = CreateVariant(124);
var thirdVariant = CreateVariant(125);
var fourthVariant = CreateVariant(128);
var fifthVariant = CreateVariant(129);
var thirdVariantFailing = CreateVariant(125);
thirdVariantFailing.Filters = "LowQ";
// -------------------------------------------------
// Add two variants that should be chained together
// - When there are no neighborhoods
// - When there is a neighborhood that they can join
// - When there are neighborhoods available but they cannot join
// -------------------------------------------------
var neighborhoodManager = CreateNbhdBuilder(_sourceVcf0);
var numRaw = 0;
Assert.Equal(0, neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw).Count());
Assert.Equal(0, numRaw);
neighborhoodManager = CreateNbhdBuilder(_sourceVcf1);
var neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(1, numRaw);
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant
}, neighborhoods.First());
neighborhoodManager = CreateNbhdBuilder(_sourceVcf2);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(1, numRaw);
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, thirdVariant
}, neighborhoods.First());
neighborhoodManager = CreateNbhdBuilder(_sourceVcf3);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(2, numRaw);
Assert.Equal(2, neighborhoods.Count());
var neighborhood1 = neighborhoods.Last();
Assert.True(neighborhood1.HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, thirdVariant
}, neighborhoods.First());
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
fourthVariant, fifthVariant
}, neighborhood1);
// Different phasing distance
neighborhoodManager = CreateNbhdBuilder(_sourceVcf4, 5);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(1, numRaw);
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, fourthVariant, fifthVariant
}, neighborhoods.First());
// -------------------------------------------------
// Passing/Failing Variants Allowed
// -------------------------------------------------
// Passing Only
neighborhoodManager = CreateNbhdBuilder(_sourceVcf5);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(2, numRaw);
Assert.Equal(2, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant
}, neighborhoods.First());
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
fourthVariant, fifthVariant
}, neighborhoods.Last());
// Passing Only, Larger phasing distance
neighborhoodManager = CreateNbhdBuilder(_sourceVcf5, 5);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(1, numRaw);
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, fourthVariant, fifthVariant
}, neighborhoods.First());
// Passing Only = false
neighborhoodManager = CreateNbhdBuilder(_sourceVcf5, passingOnly: false);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(2, numRaw);
Assert.Equal(2, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, thirdVariantFailing
}, neighborhoods.First());
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
fourthVariant, fifthVariant
}, neighborhoods.Last());
// Passing Only = false, Larger phasing distance
neighborhoodManager = CreateNbhdBuilder(_sourceVcf5, 5, false);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(1, numRaw);
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, thirdVariantFailing, fourthVariant, fifthVariant
}, neighborhoods.First());
// -------------------------------------------------
// Passing/Failing Variants Allowed, with min passing variants in neighborhood
// -------------------------------------------------
// Passing Only = false, require at least one passing var
neighborhoodManager = CreateNbhdBuilder(_sourceVcf5, passingOnly: false, minPassingVariantsInNbhd: 1);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(2, numRaw);
Assert.Equal(2, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, thirdVariantFailing
}, neighborhoods.First());
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
fourthVariant, fifthVariant
}, neighborhoods.Last());
// Passing Only = false, require at least two passing var
neighborhoodManager = CreateNbhdBuilder(_sourceVcf5, passingOnly: false, minPassingVariantsInNbhd: 2);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(2, numRaw);
Assert.Equal(2, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
variant, secondVariant, thirdVariantFailing
}, neighborhoods.First());
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
fourthVariant, fifthVariant
}, neighborhoods.Last());
// Passing Only = false, require at least three passing var
neighborhoodManager = CreateNbhdBuilder(_sourceVcf5, passingOnly: false, minPassingVariantsInNbhd: 3);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(2, numRaw);
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
fourthVariant, fifthVariant
}, neighborhoods.First());
// Passing Only = false, require at least four passing var - OR be composed of all passing
neighborhoodManager = CreateNbhdBuilder(_sourceVcf5, passingOnly: false, minPassingVariantsInNbhd: 4);
neighborhoods = neighborhoodManager.GetBatchOfCallableNeighborhoods(0, out numRaw);
Assert.Equal(2, numRaw);
Assert.Equal(1, neighborhoods.Count());
Assert.True(neighborhoods.First().HasVariants);
NeighborhoodTestHelpers.CheckNeighborhoodVariants(new List <VcfVariant>()
{
fourthVariant, fifthVariant
}, neighborhoods.First());
}
