public void CallSomaticVariants_LowDepthTest()
        {
            List <ChrReference> chrRef = new List <ChrReference>()
            {
                new ChrReference()
                {
                    Name     = "chr19",
                    Sequence = "TTGTCAGTGCGCTTTTCCCAACACCACCTGCTCCGACCACCACCAGTTTGTACTCAGTCATTTCACACCAGCAAGAACCTGTTGGAAACCAGTAATCAGGGTTAATTGGCGGCGAAAAAAAAAAAAAAAAAAAAAAAAAA"
                }
            };

            var options = new ApplicationOptions()
            {
                BAMPaths    = new[] { _bamSmallS1 },
                GenomePaths = new[] { _genomeChr19 },
                //IntervalPaths = new[] { _intervalsChr17Chr19 },
                DebugMode          = true,
                CallMNVs           = true,
                UseMNVReallocation = false,
                MaxSizeMNV         = 100,
                OutputgVCFFiles    = true,
                MinimumCoverage    = 1000,
                OutputFolder       = UnitTestPaths.TestDataDirectory
            };

            var vcfFilePath = Path.ChangeExtension(options.BAMPaths[0], "genome.vcf");

            var     factory = new Factory(options);
            IGenome genomeRef;

            genomeRef = new MockGenome(chrRef);

            var bp = new BamProcessor(factory, genomeRef);

            bp.Execute(1);
            List <VcfVariant> coverage1000results = VcfReader.GetAllVariantsInFile(vcfFilePath);

            options = new ApplicationOptions()
            {
                BAMPaths    = new[] { _bamSmallS1 },
                GenomePaths = new[] { _genomeChr19 },
                // IntervalPaths = new[] { _intervalsChr17Chr19 },
                DebugMode          = true,
                CallMNVs           = true,
                UseMNVReallocation = false,
                OutputgVCFFiles    = true,
                OutputFolder       = UnitTestPaths.TestDataDirectory
            };
            factory = new Factory(options);
            bp      = new BamProcessor(factory, genomeRef);
            bp.Execute(1);
            List <VcfVariant> coverage10results = VcfReader.GetAllVariantsInFile(vcfFilePath);

            // Assert.NotEqual(coverage1000results.Count, coverage10results.Count);
            // Assert.Equal(coverage1000results.Count, 84);
            // Assert.Equal(coverage10results.Count, 100);
        }
Ejemplo n.º 2
0
        public void Execute()
        {
            var factory = new Factory(_options);

            if (!_options.ThreadByChr)
            {
                var distinctGenomeDirectories = _options.GenomePaths.Distinct();

                foreach (var genomeDirectory in distinctGenomeDirectories)
                {
                    var genome          = factory.GetReferenceGenome(genomeDirectory);
                    var genomeProcessor = new GenomeProcessor(factory, genome);
                    genomeProcessor.Execute(_options.MaxNumThreads);
                }
            }
            else
            {
                var workRequest = factory.WorkRequests.First();

                var genome       = factory.GetReferenceGenome(workRequest.GenomeDirectory);
                var bamProcessor = new BamProcessor(factory, genome);
                bamProcessor.Execute(_options.MaxNumThreads);
            }
        }
        public void Execute(
            string bamFilePath,
            string vcfFilePath,
            string intervalPath,
            List <BaseCalledAllele> expectedVariants,
            List <ChrReference> fakeReferences = null,
            bool doCheckVariants            = true,
            bool doCheckReferences          = false,
            int expectedNumCoveredPositions = 0,
            bool threadByChr = false,
            int doCountsOnly = 0,
            bool doLog       = false,
            bool callMnvs    = true,
            ApplicationOptions applicationOptions = null)
        {
            if (doCheckReferences)
            {
                vcfFilePath = Path.ChangeExtension(vcfFilePath, "genome.vcf");
            }

            if (applicationOptions == null)
            {
                applicationOptions = new ApplicationOptions
                {
                    BAMPaths               = new[] { bamFilePath },
                    IntervalPaths          = string.IsNullOrEmpty(intervalPath) ? null : new[] { intervalPath },
                    GenomePaths            = new[] { GenomeDirectory },
                    OutputgVCFFiles        = doCheckReferences,
                    OutputBiasFiles        = true,
                    DebugMode              = doLog,
                    MinimumBaseCallQuality = 20,
                    CallMNVs               = callMnvs
                };
            }

            Logger.TryOpenLog(applicationOptions.LogFolder, ApplicationOptions.LogFileName);

            var factory = GetFactory(applicationOptions);

            IGenome genome;

            if (fakeReferences == null)
            {
                genome = factory.GetReferenceGenome(GenomeDirectory);
            }
            else
            {
                genome = new MockGenome(fakeReferences, GenomeDirectory);
            }

            if (threadByChr)
            {
                var processor = new BamProcessor(factory, genome);

                processor.Execute(1);
            }
            else
            {
                var processor = new GenomeProcessor(factory, genome);

                processor.Execute(1);
            }

            Logger.TryCloseLog();

            using (var reader = new VcfReader(vcfFilePath))
            {
                var alleles = reader.GetVariants().ToList();

                var variantCalls = alleles.Where(a => a.VariantAlleles[0] != ".").ToList();

                if (doCheckVariants)
                {
                    if (doCountsOnly > 0)
                    {
                        Assert.Equal(variantCalls.Count(), doCountsOnly);
                    }
                    else
                    {
                        CheckVariants(variantCalls, expectedVariants);
                    }
                }

                if (doCheckReferences)
                {
                    var referenceAlleles = alleles.Where(a => a.VariantAlleles[0] == ".").ToList();

                    // make sure no reference calls at variant positions
                    Assert.Equal(referenceAlleles.Count(), alleles.Count(a => !variantCalls.Select(v => v.ReferencePosition).Contains(a.ReferencePosition)));
                }
            }
        }
Ejemplo n.º 4
0
        private void ExecuteChromosomeThreadingTest(int numberOfThreads, int expectedNumberOfThreads)
        {
            var bamFilePath = Path.Combine(UnitTestPaths.TestDataDirectory, "var123var35.bam");
            var vcfFilePath = Path.Combine(UnitTestPaths.TestDataDirectory, "var123var35.vcf");
            var genomePath  = Path.Combine(UnitTestPaths.TestGenomesDirectory, "chr17chr19");

            var options = new ApplicationOptions
            {
                BAMPaths    = new[] { bamFilePath },
                GenomePaths = new[] { genomePath },
            };

            var logFile = Path.Combine(options.LogFolder, ApplicationOptions.LogFileName);

            if (File.Exists(logFile))
            {
                File.Delete(logFile);
            }

            Logger.TryOpenLog(options.LogFolder, ApplicationOptions.LogFileName);

            var factory = new MockFactoryWithDefaults(options);

            factory.MockSomaticVariantCaller = new Mock <ISomaticVariantCaller>();
            factory.MockSomaticVariantCaller.Setup(s => s.Execute()).Callback(() =>
            {
                Thread.Sleep(500);
            });
            var processor = new BamProcessor(factory, factory.GetReferenceGenome(genomePath));

            processor.Execute(numberOfThreads);

            Assert.False(File.Exists(vcfFilePath + "_chr17"));
            Assert.False(File.Exists(vcfFilePath + "_chr19"));
            Assert.True(File.Exists(vcfFilePath));

            Logger.TryCloseLog();

            var threadsSpawnedBeforeFirstCompleted = 0;

            using (var reader = new StreamReader(logFile))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    if (string.IsNullOrEmpty(line))
                    {
                        continue;
                    }

                    if (line.Contains("Completed processing chr"))
                    {
                        break;
                    }

                    if (line.Contains("Start processing chr"))
                    {
                        threadsSpawnedBeforeFirstCompleted++;
                    }
                }
            }

            Assert.Equal(expectedNumberOfThreads, threadsSpawnedBeforeFirstCompleted);
        }