public void Right_Identity_WhenRefSequenceNull()
        {
            var originalVariant = GetDeletion();
            var rotatedVariant  = VariantRotator.Right(originalVariant, null, null, false);

            Assert.True(ReferenceEquals(originalVariant, rotatedVariant));
        }
        public void Right_Identity_WhenNotInsertionOrDeletion()
        {
            var originalVariant = new SimpleVariant(ChromosomeUtilities.Chr1, 966392, 966392, "T", "A", VariantType.SNV);
            var rotated         = VariantRotator.Right(originalVariant, null, _refSequence, false);

            Assert.True(ReferenceEquals(originalVariant, rotated));
        }
        public static IAnnotatedTranscript GetAnnotatedTranscript(ITranscript transcript, IVariant leftShiftedVariant,
                                                                  ISequence refSequence, IPredictionCache siftCache, IPredictionCache polyphenCache, AminoAcids aminoAcids)
        {
            var rightShiftedVariant = VariantRotator.Right(leftShiftedVariant, transcript, refSequence,
                                                           transcript.Gene.OnReverseStrand);

            var leftAnnotation = AnnotateTranscript(transcript, leftShiftedVariant, aminoAcids, refSequence);

            var rightAnnotation = ReferenceEquals(leftShiftedVariant, rightShiftedVariant)
                ? leftAnnotation
                : AnnotateTranscript(transcript, rightShiftedVariant, aminoAcids, refSequence);

            var consequences = GetConsequences(transcript, leftShiftedVariant, leftAnnotation.VariantEffect);

            var hgvsCoding = HgvsCodingNomenclature.GetHgvscAnnotation(transcript, rightShiftedVariant, refSequence,
                                                                       rightAnnotation.Position.RegionStartIndex, rightAnnotation.Position.RegionEndIndex);

            var hgvsProtein = HgvsProteinNomenclature.GetHgvsProteinAnnotation(transcript,
                                                                               rightAnnotation.RefAminoAcids, rightAnnotation.AltAminoAcids, rightAnnotation.TranscriptAltAllele,
                                                                               rightAnnotation.Position, rightAnnotation.VariantEffect, rightShiftedVariant, refSequence, hgvsCoding,
                                                                               leftShiftedVariant.Chromosome.UcscName == "chrM");

            var predictionScores = GetPredictionScores(leftAnnotation.Position, leftAnnotation.RefAminoAcids,
                                                       leftAnnotation.AltAminoAcids, siftCache, polyphenCache, transcript.SiftIndex, transcript.PolyPhenIndex);

            return(new AnnotatedTranscript(transcript, leftAnnotation.RefAminoAcids, leftAnnotation.AltAminoAcids,
                                           leftAnnotation.RefCodons, leftAnnotation.AltCodons, leftAnnotation.Position, hgvsCoding, hgvsProtein,
                                           predictionScores.Sift, predictionScores.PolyPhen, consequences, false));
        }
        public void Right_Identity_WhenNotInsertionOrDeletion()
        {
            var originalVariant = GetDeletion();

            originalVariant.SetupGet(x => x.Type).Returns(VariantType.SNV);
            var rotated = VariantRotator.Right(originalVariant.Object, null, _refSequence, false);

            Assert.True(ReferenceEquals(originalVariant.Object, rotated));
        }
        public void Right_Identity_VariantBeforeTranscript_ForwardStrand()
        {
            var originalVariant = GetDeletion();

            var transcript = new Mock <ITranscript>();

            transcript.SetupGet(x => x.Start).Returns(966397);
            transcript.SetupGet(x => x.Gene.OnReverseStrand).Returns(false);

            var rotated = VariantRotator.Right(originalVariant, transcript.Object, _refSequence, transcript.Object.Gene.OnReverseStrand);

            Assert.True(ReferenceEquals(originalVariant, rotated));
        }
        public void Right_Insertion()
        {
            var variant = GetInsertion();

            var transcript = new Mock <ITranscript>();

            transcript.SetupGet(x => x.Start).Returns(966300);
            transcript.SetupGet(x => x.End).Returns(966405);
            transcript.SetupGet(x => x.Gene.OnReverseStrand).Returns(false);

            var rotated = VariantRotator.Right(variant, transcript.Object, _refSequence, transcript.Object.Gene.OnReverseStrand);

            Assert.False(ReferenceEquals(variant, rotated));
            Assert.Equal(966403, rotated.Start);
            Assert.Equal("TG", rotated.AltAllele);
        }
        public void Right_Deletion_ReverseStrand()
        {
            var variant = new SimpleVariant(ChromosomeUtilities.Chr1, 966399, 966401, "TG", "", VariantType.deletion);

            var transcript = new Mock <ITranscript>();

            transcript.SetupGet(x => x.Start).Returns(966300);
            transcript.SetupGet(x => x.End).Returns(966405);
            transcript.SetupGet(x => x.Gene.OnReverseStrand).Returns(true);

            var rotatedVariant = VariantRotator.Right(variant, transcript.Object, _refSequence, transcript.Object.Gene.OnReverseStrand);

            Assert.False(ReferenceEquals(variant, rotatedVariant));
            Assert.Equal(966393, rotatedVariant.Start);
            Assert.Equal("TG", rotatedVariant.RefAllele);
        }
        public void Right_Deletion_ForwardStrand()
        {
            // chr1	966391	.	ATG	A	2694.00	PASS	.
            var variant = GetDeletion();

            var transcript = new Mock <ITranscript>();

            transcript.SetupGet(x => x.Start).Returns(966300);
            transcript.SetupGet(x => x.End).Returns(966405);
            transcript.SetupGet(x => x.Gene.OnReverseStrand).Returns(false);

            var rotatedVariant = VariantRotator.Right(variant, transcript.Object, _refSequence, transcript.Object.Gene.OnReverseStrand);

            Assert.False(ReferenceEquals(variant, rotatedVariant));
            Assert.Equal(966400, rotatedVariant.Start);
            Assert.Equal("TG", rotatedVariant.RefAllele);
        }
        public void Right_Identity_WithNoRotation()
        {
            var originalVariant = GetDeletion();

            ISequence refSequence = new SimpleSequence(
                new string('A', VariantRotator.MaxDownstreamLength) + "GAGAGTTAGGTA" +
                new string('A', VariantRotator.MaxDownstreamLength), 965891);

            var transcript = new Mock <ITranscript>();

            transcript.SetupGet(x => x.Start).Returns(966300);
            transcript.SetupGet(x => x.End).Returns(966405);
            transcript.SetupGet(x => x.Gene.OnReverseStrand).Returns(false);

            var rotated = VariantRotator.Right(originalVariant, transcript.Object, refSequence, transcript.Object.Gene.OnReverseStrand);

            Assert.True(ReferenceEquals(originalVariant, rotated));
        }
Beispiel #10
0
        public static string GetNotation(string refseqAccession, ISimpleVariant variant, ISequence refSequence,
                                         IInterval referenceInterval)
        {
            var rotatedVariant = VariantRotator.Right(variant, referenceInterval, refSequence, false);
            var start          = Math.Min(rotatedVariant.Start, rotatedVariant.End);
            var end            = Math.Max(rotatedVariant.Start, rotatedVariant.End);
            var referenceBases = rotatedVariant.RefAllele;
            var alternateBases = rotatedVariant.AltAllele;
            var type           = HgvsCodingNomenclature.GetGenomicChange(referenceInterval, false, refSequence, rotatedVariant);

            if (type == GenomicChange.Duplication && variant.Type == VariantType.insertion)
            {
                referenceBases = alternateBases;
                end            = start;
                start          = end - referenceBases.Length + 1;
            }

            return(HgvsUtilities.FormatDnaNotation(start.ToString(), end.ToString(), refseqAccession, referenceBases, alternateBases, type, NotationType));
        }