Example #1
0
        public void GetAlleleBlockToSampleHaplotype_AlleleBlock_WithInternalRefPositions_SplitIfOutOfRange()
        {
            var genotypeBlock1   = new GenotypeBlock(new[] { "1|2", "0/0", "0|0", "1/1" }.Select(Genotype.GetGenotype).ToArray());
            var genotypeBlock2   = new GenotypeBlock(new[] { "1/1", "0|0", "1|1" }.Select(Genotype.GetGenotype).ToArray());
            var genotypeBlock3   = new GenotypeBlock(new[] { "1|2", "0|0", "1|1" }.Select(Genotype.GetGenotype).ToArray(), 1);
            var genotypeToSample =
                new Dictionary <GenotypeBlock, List <int> >
            {
                { genotypeBlock1, new List <int> {
                      0
                  } },
                { genotypeBlock2, new List <int> {
                      1
                  } },
                { genotypeBlock3, new List <int> {
                      2
                  } }
            };
            var indexOfUnsupportedVars = Enumerable.Repeat(new HashSet <int>(), genotypeBlock1.Genotypes.Length).ToArray();

            var starts = new[] { 100, 102, 103, 104 };
            var functionBlockRanges = starts.Select(x => x + 2).ToList();

            var alleleBlockToSampleHaplotype = AlleleBlock.GetAlleleBlockToSampleHaplotype(genotypeToSample,
                                                                                           indexOfUnsupportedVars, starts, functionBlockRanges, out _);
            var expectedBlock1 = new AlleleBlock(1, new[] { 1, 0, 1 }, 0, 0);
            var expectedBlock2 = new AlleleBlock(1, new[] { 2, 0, 1 }, 0, 0);

            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock1));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock1].SequenceEqual(new[] { new SampleHaplotype(2, 0) }));
            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock2));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock2].SequenceEqual(new[] { new SampleHaplotype(2, 1) }));
        }
Example #2
0
        public static GenotypeBlock CreateWithGenotypes(int posIndex, string[] genotypeIndexes)
        {
            var blockInfo = new GenotypeBlock(posIndex, genotypeIndexes.Length);

            blockInfo.AddAlleleIndexes(genotypeIndexes);
            return(blockInfo);
        }
Example #3
0
        public void GetAlleleBlockToSampleHaplotype_AwareOfTrimmedRefPositions()
        {
            var genotypeBlock1   = new GenotypeBlock(new[] { "0|0", "1|1", "1|1", "0|0" }.Select(Genotype.GetGenotype).ToArray());
            var genotypeBlock2   = new GenotypeBlock(new[] { "0|0", "1|1", "1|1" }.Select(Genotype.GetGenotype).ToArray());
            var genotypeBlock3   = new GenotypeBlock(new[] { "1|1", "1|1", "0|0" }.Select(Genotype.GetGenotype).ToArray(), 1);
            var genotypeBlock4   = new GenotypeBlock(new[] { "1|1", "1|1" }.Select(Genotype.GetGenotype).ToArray(), 1);
            var genotypeToSample =
                new Dictionary <GenotypeBlock, List <int> >
            {
                { genotypeBlock1, new List <int> {
                      0
                  } },
                { genotypeBlock2, new List <int> {
                      1
                  } },
                { genotypeBlock3, new List <int> {
                      2
                  } },
                { genotypeBlock4, new List <int> {
                      3
                  } }
            };
            var indexOfUnsupportedVars = Enumerable.Repeat(new HashSet <int>(), 4).ToArray();
            var starts = Enumerable.Range(100, 4).ToArray();
            var functionBlockRanges = starts.Select(x => x + 2).ToList();


            var alleleBlockToSampleHaplotype = AlleleBlock.GetAlleleBlockToSampleHaplotype(genotypeToSample,
                                                                                           indexOfUnsupportedVars, starts, functionBlockRanges, out _);
            var expectedBlock1 = new AlleleBlock(1, new[] { 1, 1 }, 1, 1);
            var expectedBlock2 = new AlleleBlock(1, new[] { 1, 1 }, 1, 0);
            var expectedBlock3 = new AlleleBlock(1, new[] { 1, 1 }, 0, 1);
            var expectedBlock4 = new AlleleBlock(1, new[] { 1, 1 }, 0, 0);

            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock1));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock1]
                        .SequenceEqual(new[] { new SampleHaplotype(0, 0), new SampleHaplotype(0, 1) }));
            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock2));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock2]
                        .SequenceEqual(new[] { new SampleHaplotype(1, 0), new SampleHaplotype(1, 1) }));
            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock3));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock3]
                        .SequenceEqual(new[] { new SampleHaplotype(2, 0), new SampleHaplotype(2, 1) }));
            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock4));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock4]
                        .SequenceEqual(new[] { new SampleHaplotype(3, 0), new SampleHaplotype(3, 1) }));
        }
Example #4
0
        public void GetAlleleBlockToSampleHaplotype_AlleleBlock_OneAlleleIsRef_EachTime()
        {
            var genotypeBlock1 = new GenotypeBlock(new[] { "1|0", "0|1", "1|0", "0|1" }.Select(Genotype.GetGenotype).ToArray());
            var genotypeBlock2 = new GenotypeBlock(new[] { "1/1", "0|1", "1|0" }.Select(Genotype.GetGenotype).ToArray(), 1);
            var genotypeBlock3 = new GenotypeBlock(new[] { "0|0", "1|0", "0|1", "0|0" }.Select(Genotype.GetGenotype).ToArray());
            var genotypeBlock4 = new GenotypeBlock(new[] { "0|1", "1|0", "1|0" }.Select(Genotype.GetGenotype).ToArray());

            var genotypeToSample =
                new Dictionary <GenotypeBlock, List <int> >
            {
                { genotypeBlock1, new List <int> {
                      0
                  } },
                { genotypeBlock2, new List <int> {
                      1
                  } },
                { genotypeBlock3, new List <int> {
                      2
                  } },
                { genotypeBlock4, new List <int> {
                      3
                  } }
            };
            var indexOfUnsupportedVars = Enumerable.Repeat(new HashSet <int>(), genotypeBlock1.Genotypes.Length).ToArray();

            var starts = new[] { 100, 101, 102, 104 };
            var functionBlockRanges = starts.Select(x => x + 2).ToList();

            var alleleBlockToSampleHaplotype = AlleleBlock.GetAlleleBlockToSampleHaplotype(genotypeToSample,
                                                                                           indexOfUnsupportedVars, starts, functionBlockRanges, out _);
            var expectedBlock1 = new AlleleBlock(0, new[] { 1, 0, 1 }, 0, 0);
            var expectedBlock2 = new AlleleBlock(0, new[] { 0, 1, 0 }, 0, 0);
            var expectedBlock3 = new AlleleBlock(1, new[] { 1, 0 }, 0, 0);
            var expectedBlock4 = new AlleleBlock(1, new[] { 1, 1 }, 0, 0);
            var expectedBlock5 = new AlleleBlock(1, new[] { 0, 0 }, 0, 0);

            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock1));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock1].SequenceEqual(new[] { new SampleHaplotype(0, 0) }));
            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock2));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock2].SequenceEqual(new[] { new SampleHaplotype(0, 1) }));
            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock3));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock3].SequenceEqual(new[] { new SampleHaplotype(1, 0) }));
            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock4));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock4].SequenceEqual(new[] { new SampleHaplotype(1, 1), new SampleHaplotype(3, 0) }));
            Assert.True(alleleBlockToSampleHaplotype.ContainsKey(expectedBlock5));
            Assert.True(alleleBlockToSampleHaplotype[expectedBlock5].SequenceEqual(new[] { new SampleHaplotype(3, 1) }));
        }
Example #5
0
        public void GetPositionsAndRefAltAlleles_AsExpected()
        {
            var genotypeBlock    = new GenotypeBlock(new[] { "1|2", "1/1", "0|1", "0/1" }.Select(Genotype.GetGenotype).ToArray());
            var genotypeToSample =
                new Dictionary <GenotypeBlock, List <int> > {
                { genotypeBlock, new List <int> {
                      0
                  } }
            };
            var indexOfUnsupportedVars = Enumerable.Repeat(new HashSet <int>(), genotypeBlock.Genotypes.Length).ToArray();
            var starts = new[] { 356, 358, 360, 361 };
            var functionBlockRanges = new List <int> {
                358, 360, 362, 364
            };
            var          alleles     = new[] { new[] { "G", "C", "T" }, new[] { "A", "T" }, new[] { "C", "G" }, new[] { "G", "T" } };
            const string refSequence = "GAATCG";
            var          alleleBlockToSampleHaplotype       = AlleleBlock.GetAlleleBlockToSampleHaplotype(genotypeToSample, indexOfUnsupportedVars, starts, functionBlockRanges, out var alleleBlockGraph);
            var          mergedAlleleBlockToSampleHaplotype =
                AlleleBlockMerger.Merge(alleleBlockToSampleHaplotype, alleleBlockGraph).ToArray();
            var alleleSet    = new AlleleSet(ChromosomeUtilities.Chr1, starts, alleles);
            var alleleBlocks = mergedAlleleBlockToSampleHaplotype.Select(x => x.Key).ToArray();
            var sequence     = new NSequence();

            var result1 = VariantGenerator.GetPositionsAndRefAltAlleles(alleleBlocks[0], alleleSet, refSequence, starts[0], null, sequence, _vidCreator);
            var result2 = VariantGenerator.GetPositionsAndRefAltAlleles(alleleBlocks[1], alleleSet, refSequence, starts[0], null, sequence, _vidCreator);

            var expectedVarPosIndexes1 = new List <int> {
                0, 1
            };
            var expectedVarPosIndexes2 = new List <int> {
                0, 1, 2
            };

            Assert.Equal((356, 360, "GAATC", "CATTC"), (result1.Start, result1.End, result1.Ref, result1.Alt));
            for (var i = 0; i < expectedVarPosIndexes1.Count; i++)
            {
                Assert.Equal(expectedVarPosIndexes1[i], result1.VarPosIndexesInAlleleBlock[i]);
            }

            Assert.Equal((356, 360, "GAATC", "TATTG"), (result2.Start, result2.End, result2.Ref, result2.Alt));
            for (var i = 0; i < expectedVarPosIndexes2.Count; i++)
            {
                Assert.Equal(expectedVarPosIndexes2[i], result2.VarPosIndexesInAlleleBlock[i]);
            }
        }
        public void Merge_AsExpected()
        {
            var genotypeBlock1   = new GenotypeBlock(new[] { "1|0", "1|1", "1|1" }.Select(Genotype.GetGenotype).ToArray());
            var genotypeBlock2   = new GenotypeBlock(new[] { "0|0", "1|0", "1|1" }.Select(Genotype.GetGenotype).ToArray());
            var genotypeToSample =
                new Dictionary <GenotypeBlock, List <int> >
            {
                { genotypeBlock1, new List <int> {
                      0
                  } },
                { genotypeBlock2, new List <int> {
                      1
                  } }
            };
            var indexOfUnsupportedVars = Enumerable.Repeat(new HashSet <int>(), 3).ToArray();
            var starts = Enumerable.Range(100, 3).ToArray();
            var functionBlockRanges          = starts.Select(x => x + 2).ToList();
            var alleleBlockToSampleHaplotype = AlleleBlock.GetAlleleBlockToSampleHaplotype(genotypeToSample,
                                                                                           indexOfUnsupportedVars, starts, functionBlockRanges, out var alleleBlockGraph);
            var mergedAlleleBlockToSampleHaplotype =
                AlleleBlockMerger.Merge(alleleBlockToSampleHaplotype, alleleBlockGraph);

            var expectedBlock1 = new AlleleBlock(0, new[] { 1, 1, 1 }, -1, -1);
            var expectedBlock2 = new AlleleBlock(0, new[] { 0, 1, 1 }, -1, -1);
            var expectedBlock3 = new AlleleBlock(0, new[] { 0, 0, 1 }, -1, -1);

            Assert.True(mergedAlleleBlockToSampleHaplotype.ContainsKey(expectedBlock1));
            Assert.True(mergedAlleleBlockToSampleHaplotype[expectedBlock1]
                        .SequenceEqual(new[] { new SampleHaplotype(0, 0) }));
            Assert.True(mergedAlleleBlockToSampleHaplotype.ContainsKey(expectedBlock2));
            Assert.True(mergedAlleleBlockToSampleHaplotype[expectedBlock2]
                        .SequenceEqual(new[] { new SampleHaplotype(0, 1), new SampleHaplotype(1, 0) }));
            Assert.True(mergedAlleleBlockToSampleHaplotype.ContainsKey(expectedBlock3));
            Assert.True(mergedAlleleBlockToSampleHaplotype[expectedBlock3]
                        .SequenceEqual(new[] { new SampleHaplotype(1, 1) }));
        }