Exemple #1
0
        public void TestHomoPolymerScenario(Read read1, Read read2, Read mergedRead, bool useSoftClippedBases, bool expectedResult)
        {
            var alignmentSet  = new AlignmentSet(read1, read2);
            var basicStitcher = new BasicStitcher(10, useSoftclippedBases: useSoftClippedBases);

            Assert.Equal(expectedResult, basicStitcher.TryStitch(alignmentSet));
            //Assert.Equal(expectedResult, OverlapEvaluator.BridgeAnchored(mergedRead));
        }
Exemple #2
0
        public void RunStitchingScenarios(StitchingScenario scenario, string resultFile)
        {
            Console.WriteLine(scenario.Category + " " + scenario.Id);

            bool resultLogged = false;

            try
            {
                var stitcher = new BasicStitcher(10);

                var inputRead1 = scenario.InputRead1.ToRead();
                var inputRead2 = scenario.InputRead2.ToRead();

                var alignmentSet = new AlignmentSet(inputRead1, inputRead2);
                var didStitch    = stitcher.TryStitch(alignmentSet);

                LogResult(resultFile, scenario, didStitch, alignmentSet);
                resultLogged = true;


                if (scenario.ShouldStitch)
                {
                    Assert.Equal(scenario.ShouldStitch, didStitch);
                    Assert.True(OutputDirectionsMatch(scenario, alignmentSet));
                    Assert.True(OutputCigarsMatch(scenario, alignmentSet));
                }

                if (didStitch)
                {
                    // TODO fix scenario source files so we can turn this back on.
                    Assert.True(OutputCigarsMatch(scenario, alignmentSet));
                }
            }
            catch (Exception ex)
            {
                if (!resultLogged)
                {
                    LogResult(resultFile, scenario, false, null, message: "Threw exception: " + ex.Message);
                }
                throw;
            }
        }
        public void TryStitch_RealExamples()
        {
            // Real example from Kristina's problematic variant #73
            var read1Bases =
                "GAAGCCACACTGACGTGCCTCTCCCTCCCTCCAGGAAGCCTTCCAGGAAGCCTACGTGATGGCCAGCGTGGACAACCCCCACGTGTGCCGCCTGCTGGGCATCTGCCTCACCTCCACCGTGCAGCTCATCACGCAGCTCATGCCCTTCGG";
            var read2Bases =
                "AGGAAGCCTTCCAGGAAGCCTACGTGATGGCCAGCGTGGACAACCCCCACGTGTGCCGCCTGCTGGGCATCTGCCTCACCTCCACCGTGCAGCTCATCACGCAGCTCATGCCCTTCGGCTGCCTCCTGGACTATGTCCGGGAACACAAAG";

            var read1 = DomainTestHelper.CreateRead("chr7", read1Bases, 55248972, new CigarAlignment("20S9M12I109M"));
            var read2 = DomainTestHelper.CreateRead("chr7", read2Bases, 55248981, new CigarAlignment("9S120M21S"));

            StitcherTestHelpers.SetReadDirections(read2, DirectionType.Reverse);

            var stitcher     = new BasicStitcher(10, useSoftclippedBases: false);
            var alignmentSet = new AlignmentSet(read1, read2);

            stitcher.TryStitch(alignmentSet);
            var mergedRead = StitcherTestHelpers.GetMergedRead(alignmentSet);

            Assert.Equal("20S9M12I120M21S", mergedRead.CigarData.ToString());
            Assert.Equal("41F109S32R", mergedRead.CigarDirections.ToString());

            // Shouldn't stitch - problem Yu was having (tried to merge and then said the base at position 158 is null).
            read1Bases =
                "CGACGCTCTTGCGATCTTCAAAGCAATAGGATGGGTGATCAGGGATGTTGCTTACAAGAAAAGAACTGCCATACAGCTTCAACAACAACTTCTTCCACCCACCCCTAAAATGATGCTAAAAAGTAAGTCATCTCTGGTTCTCCCCCGATT";
            read2Bases =
                "TCAAAGCAATAGGATGGATGATCAGAGATGTTGCTTACAAGAAAAGAACTGCCATACAGCTTCAACAACAACTTCTTCCACTCCCCCCTAAAGTGATGCTAAAAAGTAAATCATCCCTGTTTCTCCCCCGTTCGCGAATTTCTACGATCG";

            read1 = DomainTestHelper.CreateRead("chr7", read1Bases, 109465121, new CigarAlignment("44S56M1I23M26S"));
            read2 = DomainTestHelper.CreateRead("chr7", read2Bases, 109465121, new CigarAlignment("27S55M1I24M43S"));
            StitcherTestHelpers.SetReadDirections(read2, DirectionType.Reverse);

            stitcher     = new BasicStitcher(10, useSoftclippedBases: true);
            alignmentSet = new AlignmentSet(read1, read2);
            Assert.False(stitcher.TryStitch(alignmentSet));
        }
        public void TryStitch_ReCo()
        {
            // Real example from ReCo, was failing to generate the correct stitched cigar
            var read1Bases =
                "GTACTCCTACAGTCCCACCCCTCCCCTATAAACCTTATGAATCCCCGTTCACTTAGATGCCAGCTTGGCAAGGAAGGGAAGTACACATCTGTTGACAGTAATGAAATATCCTTGATAAGGATTTAAATTTTGGATGTGCTG";
            var read2Bases =
                "ACCTACAGTCCCACCCCTCCCCTATAAACCTTAGGAATCCCCGTTCACTTAGATGCCAGCTTGGCAAGGAAGGGAAGTACACATCTGTTGACAGTAATGAAATATCCTTGATAAGGATTTAAATTTTGGATGTGCTGAGCT";

            // 8             9
            // 3 4 5 6 7 8 9 0 1 2
            // s s s s s M M M M M ...
            // - - - - M M M M M M ...
            // F F F F R S S S S S ... // Stitched directions if we don't allow softclip to contribute
            // F F F F S S S S S S ... // Stitched directions if we do allow softclip to contribute

            var read1 = DomainTestHelper.CreateRead("chr21", read1Bases, 16685488,
                                                    new CigarAlignment("5S136M"));

            var read2 = DomainTestHelper.CreateRead("chr21", read2Bases, 16685487,
                                                    new CigarAlignment("137M4S"));

            StitcherTestHelpers.SetReadDirections(read2, DirectionType.Reverse);

            var stitcher     = new BasicStitcher(10, useSoftclippedBases: false);
            var alignmentSet = new AlignmentSet(read1, read2);

            stitcher.TryStitch(alignmentSet);
            // Without allowing softclips to count to support, should still get a M at an M/S overlap, but it won't be stitched.
            var mergedRead = StitcherTestHelpers.GetMergedRead(alignmentSet);

            Assert.Equal("4S137M4S", mergedRead.CigarData.ToString());
            var expectedDirections = StitcherTestHelpers.BuildDirectionMap(new List <IEnumerable <DirectionType> >
            {
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Forward, 4),
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Reverse, 1),
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Stitched, 136),
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Reverse, 4)
            });

            StitcherTestHelpers.VerifyDirectionType(expectedDirections, mergedRead.CigarDirections.Expand().ToArray());

            stitcher     = new BasicStitcher(10, useSoftclippedBases: true);
            alignmentSet = new AlignmentSet(read1, read2);
            stitcher.TryStitch(alignmentSet);
            mergedRead = StitcherTestHelpers.GetMergedRead(alignmentSet);
            Assert.Equal("4S137M4S", mergedRead.CigarData.ToString());
            expectedDirections = StitcherTestHelpers.BuildDirectionMap(new List <IEnumerable <DirectionType> >
            {
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Forward, 4),
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Reverse, 1),
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Stitched, 136),
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Reverse, 4)
            });
            StitcherTestHelpers.VerifyDirectionType(expectedDirections, mergedRead.CigarDirections.Expand().ToArray());

            // If we're not ignoring probe softclips, go back to the original expected directions (1 more stitched from probe)
            stitcher     = new BasicStitcher(10, useSoftclippedBases: true, ignoreProbeSoftclips: false);
            alignmentSet = new AlignmentSet(read1, read2);
            stitcher.TryStitch(alignmentSet);
            mergedRead = StitcherTestHelpers.GetMergedRead(alignmentSet);
            Assert.Equal("4S137M4S", mergedRead.CigarData.ToString());
            expectedDirections = StitcherTestHelpers.BuildDirectionMap(new List <IEnumerable <DirectionType> >
            {
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Forward, 4),
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Stitched, 137),
                StitcherTestHelpers.BuildDirectionSegment(DirectionType.Reverse, 4)
            });
            StitcherTestHelpers.VerifyDirectionType(expectedDirections, mergedRead.CigarDirections.Expand().ToArray());
        }