public void GetPositionsAndRefAltAlleles_AsExpected()
        {
            var genotypes        = new[] { "1|2", "1/1", "0|1", "0/1" };
            var genotypeToSample =
                new Dictionary <(string, int), List <int> > {
                { (string.Join(";", genotypes), 0), new List <int> {
                      0
                  } }
            };
            var indexOfUnsupportedVars = Enumerable.Repeat(new HashSet <string>(), 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" } };
            var refSequence = "GAATCG";
            var alleleIndexBlocksToSample = AlleleIndexBlock.GetAlleleIndexBlockToSampleIndex(genotypeToSample, indexOfUnsupportedVars, starts, functionBlockRanges).ToArray();
            var alleleSet               = new AlleleSet(null, starts, alleles);
            var alleleIndexBlocks       = alleleIndexBlocksToSample.Select(x => x.Key).ToArray();
            var decomposedPositionIndex = new HashSet <(int, int)>();
            var result1 = VariantGenerator.GetPositionsAndRefAltAlleles(alleleIndexBlocks[0], alleleSet, refSequence, starts[0], decomposedPositionIndex);
            var result2 = VariantGenerator.GetPositionsAndRefAltAlleles(alleleIndexBlocks[1], alleleSet, refSequence, starts[0], decomposedPositionIndex);

            Assert.Equal((356, 360, "GAATC", "CATTC"), result1);
            Assert.Equal((356, 360, "GAATC", "TATTG"), result2);
        }
Exemple #2
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]);
            }
        }
        internal static (int Start, int End, string Ref, string Alt, List <int> VarPosIndexesInAlleleBlock, List <string> decomposedVids) GetPositionsAndRefAltAlleles(AlleleBlock alleleBlock, AlleleSet alleleSet, string totalRefSequence, int regionStart, List <ISimplePosition> simplePositions)
        {
            int numPositions       = alleleBlock.AlleleIndexes.Length;
            int firstPositionIndex = alleleBlock.PositionIndex;
            int lastPositionIndex  = alleleBlock.PositionIndex + numPositions - 1;

            int    blockStart     = alleleSet.Starts[firstPositionIndex];
            int    blockEnd       = alleleSet.Starts[lastPositionIndex];
            string lastRefAllele  = alleleSet.VariantArrays[lastPositionIndex][0];
            int    blockRefLength = blockEnd - blockStart + lastRefAllele.Length;
            var    refSequence    = totalRefSequence.Substring(blockStart - regionStart, blockRefLength);

            int refSequenceStart               = 0;
            var altSequenceSegments            = new LinkedList <string>();
            var variantPosIndexesInAlleleBlock = new List <int>();
            var vidListsNeedUpdate             = new List <List <string> >();
            var decomposedVids = new List <string>();

            for (int positionIndex = firstPositionIndex; positionIndex <= lastPositionIndex; positionIndex++)
            {
                int indexInBlock = positionIndex - firstPositionIndex;
                int alleleIndex  = alleleBlock.AlleleIndexes[indexInBlock];
                //only non-reference alleles considered
                if (alleleIndex == 0)
                {
                    continue;
                }

                variantPosIndexesInAlleleBlock.Add(positionIndex - firstPositionIndex);
                string refAllele                     = alleleSet.VariantArrays[positionIndex][0];
                string altAllele                     = alleleSet.VariantArrays[positionIndex][alleleIndex];
                int    positionOnRefSequence         = alleleSet.Starts[positionIndex] - blockStart;
                int    refRegionBetweenTwoAltAlleles = positionOnRefSequence - refSequenceStart;

                if (refRegionBetweenTwoAltAlleles < 0)
                {
                    string previousAltAllele = alleleSet.VariantArrays[positionIndex - 1][alleleIndex];
                    throw new UserErrorException($"Conflicting alternative alleles identified at {alleleSet.Chromosome.UcscName}:{alleleSet.Starts[positionIndex]}: both \"{previousAltAllele}\" and \"{altAllele}\" are present.");
                }

                string refSequenceBefore = refSequence.Substring(refSequenceStart, refRegionBetweenTwoAltAlleles);
                altSequenceSegments.AddLast(refSequenceBefore);
                altSequenceSegments.AddLast(altAllele);
                refSequenceStart = positionOnRefSequence + refAllele.Length;

                if (simplePositions == null)
                {
                    continue;
                }
                var thisPosition = simplePositions[positionIndex];
                // alleleIndex is 1-based for altAlleles
                int varIndex = alleleIndex - 1;

                //Only SNVs get recomposed for now
                if (thisPosition.Vids[varIndex] == null)
                {
                    thisPosition.Vids[varIndex] = SmallVariantCreator.GetVid(alleleSet.Chromosome.EnsemblName,
                                                                             thisPosition.Start, thisPosition.End, thisPosition.AltAlleles[varIndex], VariantType.SNV);
                    thisPosition.IsDecomposed[varIndex] = true;
                }
                decomposedVids.Add(thisPosition.Vids[varIndex]);

                if (thisPosition.LinkedVids[varIndex] == null)
                {
                    thisPosition.LinkedVids[varIndex] = new List <string>();
                }
                vidListsNeedUpdate.Add(thisPosition.LinkedVids[varIndex]);
            }
            altSequenceSegments.AddLast(refSequence.Substring(refSequenceStart));
            var recomposedAllele    = string.Concat(altSequenceSegments);
            var blockRefEnd         = blockStart + blockRefLength - 1;
            var recomposedVariantId = SmallVariantCreator.GetVid(alleleSet.Chromosome.EnsemblName, blockStart, blockRefEnd, recomposedAllele, VariantType.MNV);

            vidListsNeedUpdate.ForEach(x => x.Add(recomposedVariantId));
            return(blockStart, blockRefEnd, refSequence, recomposedAllele, variantPosIndexesInAlleleBlock, decomposedVids);
        }
Exemple #4
0
                         decomposedVids) GetPositionsAndRefAltAlleles(AlleleBlock alleleBlock, AlleleSet alleleSet,
                                                                      string totalRefSequence, int regionStart, List <ISimplePosition> simplePositions, ISequence sequence, IVariantIdCreator vidCreator)
        {
            int numPositions       = alleleBlock.AlleleIndexes.Length;
            int firstPositionIndex = alleleBlock.PositionIndex;
            int lastPositionIndex  = alleleBlock.PositionIndex + numPositions - 1;

            int    blockStart     = alleleSet.Starts[firstPositionIndex];
            int    blockEnd       = alleleSet.Starts[lastPositionIndex];
            string lastRefAllele  = alleleSet.VariantArrays[lastPositionIndex][0];
            int    blockRefLength = blockEnd - blockStart + lastRefAllele.Length;
            string refSequence    = totalRefSequence.Substring(blockStart - regionStart, blockRefLength);

            var refSequenceStart               = 0;
            var altSequenceSegments            = new LinkedList <string>();
            var variantPosIndexesInAlleleBlock = new List <int>();
            var vidListsNeedUpdate             = new List <List <string> >();
            var decomposedVids = new List <string>();

            if (FindConflictAllele(alleleBlock, alleleSet))
            {
                return(default);
Exemple #5
0
 internal static (int Start, int End, string Ref, string Alt) GetPositionsAndRefAltAlleles(AlleleIndexBlock alleleIndexBlock, AlleleSet alleleSet, string totalRefSequence, int regionStart, HashSet <(int, int)> decomposedPosVarIndex)