/// <summary> /// Refine layout in the delta alignments. /// </summary> public void RefineLayout() { TimeSpan timeSpan = new TimeSpan(); Stopwatch runAlgorithm = new Stopwatch(); runAlgorithm.Restart(); FileInfo inputFileinfo = new FileInfo(this.FilePath[1]); long inputFileLength = inputFileinfo.Length; FastASequencePositionParser queryParser; using(var input = File.OpenRead(FilePath[1])) { queryParser = new FastASequencePositionParser(input, true); queryParser.CacheSequencesForRandomAccess(); } runAlgorithm.Stop(); if (this.Verbose) { Output.WriteLine(OutputLevel.Verbose); Output.WriteLine(OutputLevel.Verbose, "Processed Query FastA file: {0}", Path.GetFullPath(this.FilePath[1])); Output.WriteLine(OutputLevel.Verbose, " Read/Processing time : {0}", runAlgorithm.Elapsed); Output.WriteLine(OutputLevel.Verbose, " File Size : {0}", inputFileLength); } inputFileinfo = new FileInfo(this.FilePath[0]); inputFileLength = inputFileinfo.Length; runAlgorithm.Restart(); using (var input = File.OpenRead(FilePath[0])) using (DeltaAlignmentCollection deltaCollection = new DeltaAlignmentCollection(input, queryParser)) { runAlgorithm.Stop(); if (this.Verbose) { Output.WriteLine(OutputLevel.Verbose); Output.WriteLine(OutputLevel.Verbose, "Processed DeltaAlignment file: {0}", Path.GetFullPath(this.FilePath[0])); Output.WriteLine(OutputLevel.Verbose, " Read/Processing time : {0}", runAlgorithm.Elapsed); Output.WriteLine(OutputLevel.Verbose, " File Size : {0}", inputFileLength); } runAlgorithm.Restart(); IEnumerable<DeltaAlignment> result = LayoutRefiner.RefineLayout(deltaCollection); DeltaAlignmentSorter sorter = new DeltaAlignmentSorter(); WriteDelta(result, sorter, UnsortedLayoutRefinmentOutputFilename); runAlgorithm.Stop(); timeSpan = timeSpan.Add(runAlgorithm.Elapsed); runAlgorithm.Restart(); WriteSortedDelta(sorter, UnsortedLayoutRefinmentOutputFilename, queryParser, this.OutputFile); runAlgorithm.Stop(); } if (this.Verbose) { Output.WriteLine(OutputLevel.Verbose); Output.WriteLine(OutputLevel.Verbose, "Compute time: {0}", timeSpan); Output.WriteLine(OutputLevel.Verbose, "Write time: {0}", runAlgorithm.Elapsed); } }
/// <summary> /// Initializes a new instance of the DeltaAlignmentCollection class. /// </summary> /// <param name="deltaAlignmentStream">Delta alignment stream.</param> /// <param name="readsStream">Query/Reads stream.</param> public DeltaAlignmentCollection(Stream deltaAlignmentStream, Stream readsStream) { this.DeltaAlignmentStream = deltaAlignmentStream; this.QueryStream = readsStream; this.fastASequencePositionParser = new FastASequencePositionParser(this.QueryStream, true); this.DeltaAlignmentParser = new DeltaAlignmentParser(this.DeltaAlignmentStream, this.fastASequencePositionParser); this.collectionFileReader = PlatformManager.Services.CreateTempStream(); this.LoadAllFromFile(); }
/// <summary> /// Initializes a new instance of the DeltaAlignmentCollection class. /// </summary> /// <param name="deltaAlignmentStream">Delta alignment stream.</param> /// <param name="fastASequencePositionParser">Query/Reads filename.</param> public DeltaAlignmentCollection(Stream deltaAlignmentStream, FastASequencePositionParser fastASequencePositionParser) { if (fastASequencePositionParser == null) throw new ArgumentNullException("fastASequencePositionParser"); this.disposeFastASequencePositionParser = false; this.DeltaAlignmentStream = deltaAlignmentStream; this.QueryStream = fastASequencePositionParser.Stream; this.fastASequencePositionParser = fastASequencePositionParser; this.DeltaAlignmentParser = new DeltaAlignmentParser(this.DeltaAlignmentStream, this.fastASequencePositionParser); this.collectionFileReader = PlatformManager.Services.CreateTempStream(); this.LoadAllFromFile(); }
/// <summary> /// Initializes a new instance of the DeltaAlignmentParser class by /// loading the specified filename. /// </summary> /// <param name="stream">Name of the File.</param> /// <param name="queryParser">FastASequencePositionParser instance.</param> public DeltaAlignmentParser(Stream stream, FastASequencePositionParser queryParser) { if (stream == null) { throw new ArgumentNullException("stream"); } if (queryParser == null) { throw new ArgumentNullException("queryParser"); } this.deltaStream = stream; this.QueryParser = queryParser; }
/// <summary> /// Parses the file. /// </summary> /// <param name="fileName">The FileName.</param> /// <returns>List of sequence.</returns> private static IEnumerable<ISequence> ParseWithPosition(string fileName) { using (var stream = File.OpenRead(fileName)) { FastASequencePositionParser parser = new FastASequencePositionParser(stream); return parser.Parse().ToList(); } }
/// <summary> /// Validates Assemble method .Step 1-5. /// </summary> /// <param name="nodeName">Parent Node name in Xml</param> /// <param name="isFilePath">Sequence location.</param> public void ValidateComparativeAssembleMethod(string nodeName, bool isEcOli) { ComparativeGenomeAssembler assemble = new ComparativeGenomeAssembler(); List<ISequence> referenceSeqList = new List<ISequence>(); string expectedSequence = null; string LengthOfMUM = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.MUMLengthNode); string kmerLength = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.KmerLengthNode); string fixedSeparation = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FixedSeparationNode); string minimumScore = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.MinimumScoreNode); string separationFactor = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.SeparationFactorNode); string maximumSeparation = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.MaximumSeparationNode); string breakLength = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.BreakLengthNode); // Gets the reference sequence from the FastA file string filePath = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode1); Assert.IsNotNull(filePath); ApplicationLog.WriteLine(string.Format((IFormatProvider)null, "Comparative P1 : Successfully validated the File Path '{0}'.", filePath)); using (FastAParser parser = new FastAParser(filePath)) { IEnumerable<ISequence> referenceList = parser.Parse(); foreach (ISequence seq in referenceList) { referenceSeqList.Add(seq); } } //Get the reads from configurtion file . string readFilePath = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode2); assemble.LengthOfMum = int.Parse(LengthOfMUM, CultureInfo.InvariantCulture); assemble.KmerLength = int.Parse(kmerLength, CultureInfo.InvariantCulture); assemble.FixedSeparation = int.Parse(fixedSeparation, CultureInfo.InvariantCulture); assemble.MinimumScore = int.Parse(minimumScore, CultureInfo.InvariantCulture); assemble.SeparationFactor = float.Parse(separationFactor, CultureInfo.InvariantCulture); assemble.MaximumSeparation = int.Parse(maximumSeparation, CultureInfo.InvariantCulture); assemble.BreakLength = int.Parse(breakLength, CultureInfo.InvariantCulture); using (FastASequencePositionParser queryparser = new FastASequencePositionParser(readFilePath)) { IEnumerable<ISequence> outputAssemble = assemble.Assemble(referenceSeqList, queryparser); if (isEcOli) { expectedSequence = utilityObj.xmlUtil.GetFileTextValue(nodeName, Constants.ExpectedSequenceNode); } else { expectedSequence = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.ExpectedSequenceNode); } var outputStrings = outputAssemble.Select(seq => seq.ConvertToString()).ToList(); outputStrings.Sort(); Assert.AreEqual(expectedSequence.ToUpperInvariant(), String.Join("", outputStrings).ToUpperInvariant()); } }
/// <summary> /// Disposes the underlying streams used. /// </summary> /// <param name="disposing">Flag to indicate whether it is called from dispose method or not.</param> protected virtual void Dispose(bool disposing) { if (disposing) { if (this.DeltaAlignmentParser != null) { this.DeltaAlignmentParser.Dispose(); this.DeltaAlignmentParser = null; } if (this.fastASequencePositionParser != null) { if (this.disposeFastASequencePositionParser) { this.fastASequencePositionParser.Dispose(); } this.fastASequencePositionParser = null; } if (this.collectionFileReader != null) { this.collectionFileReader.Dispose(); this.collectionFileReader = null; } this.readBuffer = null; } }
/// <summary> /// Writes delta for query sequences. /// </summary> /// <param name="sorter">The Deltas.</param> private void WriteDelta(DeltaAlignmentSorter sorter) { TextWriter textWriterConsoleOutSave = Console.Out; StreamWriter streamWriterConsoleOut = null; try { using (var reads = File.OpenRead(this.FilePath[1])) using (var unsortedDeltas = File.OpenRead(UnsortedDeltaFile)) using (var sequenceParser = new FastASequencePositionParser(reads, true)) using (var unsortedDeltaParser = new DeltaAlignmentParser(unsortedDeltas, sequenceParser)) { if (!string.IsNullOrEmpty(this.OutputFile)) { streamWriterConsoleOut = new StreamWriter(this.OutputFile); Console.SetOut(streamWriterConsoleOut); } long deltaPositionInFile = 0; foreach (long id in sorter.GetSortedIds()) { DeltaAlignment deltaAlignment = unsortedDeltaParser.GetDeltaAlignmentAt(id); deltaAlignment.Id = deltaPositionInFile; string deltaString = Helper.GetString(deltaAlignment); deltaPositionInFile += deltaString.Length; Console.Write(deltaString); } Console.Out.Flush(); } } finally { if (streamWriterConsoleOut != null) streamWriterConsoleOut.Dispose(); Console.SetOut(textWriterConsoleOutSave); } }
/// <summary> /// It assembles the sequences. /// </summary> public virtual void AssembleSequences() { if (this.FilePath.Length != 2) { Output.WriteLine(OutputLevel.Error, "Error: A reference file and 1 query file are required."); return; } TimeSpan timeSpan = new TimeSpan(); Stopwatch runAlgorithm = new Stopwatch(); FileInfo inputFileinfo = new FileInfo(this.FilePath[0]); long inputFileLength = inputFileinfo.Length; inputFileinfo = null; if (!string.IsNullOrEmpty(this.CloneLibraryName)) { CloneLibrary.Instance.AddLibrary(this.CloneLibraryName, (float)this.MeanLengthOfInsert, (float)this.StandardDeviationOfInsert); } runAlgorithm.Restart(); // Parse input files IEnumerable<ISequence> referenceSequences = ParseFile(this.FilePath[0]); runAlgorithm.Stop(); if (this.Verbose) { Output.WriteLine(OutputLevel.Verbose); Output.WriteLine(OutputLevel.Verbose, "Processed reference file: {0}", Path.GetFullPath(this.FilePath[0])); Output.WriteLine(OutputLevel.Verbose, " Read/Processing time : {0}", runAlgorithm.Elapsed); Output.WriteLine(OutputLevel.Verbose, " File Size : {0}", inputFileLength); } inputFileinfo = new FileInfo(this.FilePath[1]); inputFileLength = inputFileinfo.Length; runAlgorithm.Restart(); FastASequencePositionParser queryParser; using (var stream = File.OpenRead(this.FilePath[1])) { // Parse and cache the sequences. queryParser = new FastASequencePositionParser(stream, true); queryParser.CacheSequencesForRandomAccess(); } // Check the input var reads = queryParser.Parse(); if (reads.Any(s => s.Alphabet.HasAmbiguity)) throw new ArgumentException(Resources.AmbiguousReadsNotSupported); runAlgorithm.Stop(); if (this.Verbose) { Output.WriteLine(OutputLevel.Verbose); Output.WriteLine(OutputLevel.Verbose, "Processed reads file : {0}", Path.GetFullPath(this.FilePath[1])); Output.WriteLine(OutputLevel.Verbose, " Read/Processing time: {0}", runAlgorithm.Elapsed); Output.WriteLine(OutputLevel.Verbose, " File Size : {0}", inputFileLength); } runAlgorithm.Restart(); runAlgorithm.Stop(); if (this.Verbose) { Output.WriteLine(OutputLevel.Verbose); Output.WriteLine(OutputLevel.Verbose, "Time taken for Validating reads: {0}", runAlgorithm.Elapsed); Output.WriteLine(OutputLevel.Verbose); } runAlgorithm.Restart(); ComparativeGenomeAssembler assembler = new ComparativeGenomeAssembler(); assembler.StatusChanged += this.AssemblerStatusChanged; assembler.ScaffoldingEnabled = this.Scaffold; assembler.KmerLength = this.KmerLength; assembler.LengthOfMum = this.MumLength; IEnumerable<ISequence> assemblerResult = assembler.Assemble(referenceSequences, queryParser); runAlgorithm.Stop(); timeSpan = timeSpan.Add(runAlgorithm.Elapsed); runAlgorithm.Restart(); this.WriteContigs(assemblerResult); runAlgorithm.Stop(); if (this.Verbose) { Output.WriteLine(OutputLevel.Verbose, "Assemble time: {0}", timeSpan); Output.WriteLine(OutputLevel.Verbose, "Write time: {0}", runAlgorithm.Elapsed); } }
/// <summary> /// Writes delta for query sequences. /// </summary> /// <param name="sorter">Sorter instance.</param> /// <param name="unsortedDeltaStream">Unsorted Delta Filename.</param> /// <param name="queryParser">Query/read sequences parser.</param> /// <param name="outputStream">Output file name.</param> public static void WriteSortedDelta(DeltaAlignmentSorter sorter, Stream unsortedDeltaStream, FastASequencePositionParser queryParser, Stream outputStream) { if (sorter == null) { throw new ArgumentNullException("sorter"); } using (DeltaAlignmentParser unsortedDeltaParser = new DeltaAlignmentParser(unsortedDeltaStream, queryParser)) { using (StreamWriter writer = new StreamWriter(outputStream)) { long deltaPositionInFile = 0; foreach (long id in sorter.GetSortedIds()) { DeltaAlignment deltaAlignment = unsortedDeltaParser.GetDeltaAlignmentAt(id); deltaAlignment.Id = deltaPositionInFile; string deltaString = Helper.GetString(deltaAlignment); deltaPositionInFile += deltaString.Length; writer.Write(deltaString); } writer.Flush(); } } }
/// <summary> /// Assemble the input sequences into the largest possible contigs. /// </summary> /// <param name="referenceSequence">The sequence used as backbone for assembly.</param> /// <param name="queryParser">The parser to load the sequences to assemble.</param> /// <returns>IComparativeAssembly instance which contains list of assembled sequences.</returns> public IEnumerable<ISequence> Assemble(IEnumerable<ISequence> referenceSequence, FastASequencePositionParser queryParser) { if (referenceSequence == null) { throw new ArgumentNullException("referenceSequence"); } if (queryParser == null) { throw new ArgumentNullException("queryParser"); } Stream readAlignmentOutputStream = null; Stream unsortedRepeatResolutionOutputStream = null; Stream repeatResolutionOutputStream = null; Stream unsortedLayoutRefinmentOutputStream = null; Stream layoutRefinmentOutputStream = null; try { // Converting to list to avoid multiple parse of the reference file if its a yield return var refSequences = referenceSequence.ToList(); // CacheSequencesForRandomAccess will ignore the call if called more than once. queryParser.CacheSequencesForRandomAccess(); IEnumerable<ISequence> reads = queryParser.Parse(); // Comparative Assembly Steps // 1) Read Alignment (Calling NUCmer for aligning reads to reference sequence) this.StatusEventStart(Properties.Resource.ReadAlignmentStarted); IEnumerable<DeltaAlignment> alignmentBetweenReferenceAndReads = this.ReadAlignment(refSequences, reads.Where(a => a.Count >= this.LengthOfMum)); readAlignmentOutputStream = PlatformManager.Services.CreateTempStream(); WriteDelta(alignmentBetweenReferenceAndReads, readAlignmentOutputStream); this.StatusEventEnd(Properties.Resource.ReadAlignmentEnded); // 2) Repeat Resolution this.StatusEventStart(Properties.Resource.RepeatResolutionStarted); DeltaAlignmentSorter sorter; unsortedRepeatResolutionOutputStream = PlatformManager.Services.CreateTempStream(); using (var deltaAlignmentFromReadAlignment = new DeltaAlignmentCollection(readAlignmentOutputStream, queryParser)) { IEnumerable<DeltaAlignment> repeatResolvedDeltas = RepeatResolution(deltaAlignmentFromReadAlignment); sorter = new DeltaAlignmentSorter(refSequences[0].Count); WriteUnsortedDelta(repeatResolvedDeltas, sorter, unsortedRepeatResolutionOutputStream); } this.StatusEventEnd(Properties.Resource.RepeatResolutionEnded); this.StatusEventStart(Properties.Resource.SortingResolvedDeltasStarted); repeatResolutionOutputStream = PlatformManager.Services.CreateTempStream(); WriteSortedDelta(sorter, unsortedRepeatResolutionOutputStream, queryParser, repeatResolutionOutputStream); this.StatusEventEnd(Properties.Resource.SortingResolvedDeltasEnded); // 3) Layout Refinement this.StatusEventStart(Properties.Resource.LayoutRefinementStarted); layoutRefinmentOutputStream = PlatformManager.Services.CreateTempStream(); using (var unsortedDeltaCollectionForLayoutRefinment = new DeltaAlignmentCollection(repeatResolutionOutputStream, queryParser)) { unsortedLayoutRefinmentOutputStream = PlatformManager.Services.CreateTempStream(); IEnumerable<DeltaAlignment> layoutRefinedDeltas = LayoutRefinment(unsortedDeltaCollectionForLayoutRefinment); sorter = new DeltaAlignmentSorter(refSequences[0].Count); WriteUnsortedDelta(layoutRefinedDeltas, sorter, unsortedLayoutRefinmentOutputStream); WriteSortedDelta(sorter, unsortedLayoutRefinmentOutputStream, queryParser, layoutRefinmentOutputStream); } this.StatusEventEnd(Properties.Resource.LayoutRefinementEnded); // 4) Consensus Generation this.StatusEventStart(Properties.Resource.ConsensusGenerationStarted); IList<ISequence> contigs; using (var delta = new DeltaAlignmentCollection(layoutRefinmentOutputStream, queryParser)) { contigs = this.ConsensusGenerator(delta).ToList(); } this.StatusEventEnd(Properties.Resource.ConsensusGenerationEnded); if (this.ScaffoldingEnabled) { // 5) Scaffold Generation this.StatusEventStart(Properties.Resource.ScaffoldGenerationStarted); IEnumerable<ISequence> scaffolds = this.ScaffoldsGenerator(contigs, reads); this.StatusEventEnd(Properties.Resource.ScaffoldGenerationEnded); return scaffolds; } else { return contigs; } } finally { // Cleanup temp files. if (readAlignmentOutputStream != null) readAlignmentOutputStream.Dispose(); if (unsortedRepeatResolutionOutputStream != null) unsortedRepeatResolutionOutputStream.Dispose(); if (repeatResolutionOutputStream != null) repeatResolutionOutputStream.Dispose(); if (unsortedLayoutRefinmentOutputStream != null) unsortedLayoutRefinmentOutputStream.Dispose(); if (layoutRefinmentOutputStream != null) layoutRefinmentOutputStream.Dispose(); } }
/// <summary> /// Writes delta for query sequences. /// </summary> /// <param name="sorter">Sorter instance.</param> /// <param name="unsortedDeltaFilename">Unsorted Delta Filename.</param> /// <param name="queryParser">Query/Read parser</param> /// <param name="outputfilename">Output file name.</param> private static void WriteSortedDelta(DeltaAlignmentSorter sorter, string unsortedDeltaFilename, FastASequencePositionParser queryParser, string outputfilename) { using (var unsortedReads = File.OpenRead(unsortedDeltaFilename)) using (DeltaAlignmentParser unsortedDeltaParser = new DeltaAlignmentParser(unsortedReads, queryParser)) { TextWriter textWriterConsoleOutSave = Console.Out; StreamWriter streamWriterConsoleOut = null; try { if (!string.IsNullOrEmpty(outputfilename)) { Output.WriteLine(OutputLevel.Required); streamWriterConsoleOut = new StreamWriter(outputfilename); Console.SetOut(streamWriterConsoleOut); } long deltaPositionInFile = 0; foreach (long id in sorter.GetSortedIds()) { DeltaAlignment deltaAlignment = unsortedDeltaParser.GetDeltaAlignmentAt(id); deltaAlignment.Id = deltaPositionInFile; string deltaString = Helper.GetString(deltaAlignment); deltaPositionInFile += deltaString.Length; Console.Write(deltaString); } Console.Out.Flush(); } finally { if (streamWriterConsoleOut != null) streamWriterConsoleOut.Dispose(); Console.SetOut(textWriterConsoleOutSave); } } }
/// <summary> /// Initializes a new instance of the DeltaAlignmentParser class by /// loading the specified filename. /// </summary> /// <param name="deltaFilename">Name of the File.</param> /// <param name="queryParser">FastASequencePositionParser instance.</param> public DeltaAlignmentParser(string deltaFilename, FastASequencePositionParser queryParser) { this.Open(deltaFilename, queryParser); }
/// <summary> /// Dispose the stream. /// </summary> /// <param name="disposing"></param> public void Dispose(bool disposing) { if (disposing) { if (this.deltaStream != null) { this.deltaStream.Dispose(); this.deltaStream = null; } if (this.QueryParser != null) { this.QueryParser.Dispose(); this.QueryParser = null; } } }
/// <summary> /// Aligns reads to reference genome using NUCmer. /// </summary> /// <param name="nodeName">Name of parent Node which contains the data in xml.</param> /// <param name="isFilePath">Represents sequence is in a file or not.</param> /// <returns>Delta i.e. output from NUCmer</returns> IList<IEnumerable<DeltaAlignment>> GetDeltaAlignment(string nodeName, bool isFilePath) { string[] referenceSequences = null; string[] searchSequences = null; List<ISequence> referenceSeqList = new List<ISequence>(); List<ISequence> searchSeqList = new List<ISequence>(); IList<IEnumerable<DeltaAlignment>> results = new List<IEnumerable<DeltaAlignment>>(); if (isFilePath) { // Gets the reference sequence from the FastA file string filePath = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode1); Assert.IsNotNull(filePath); ApplicationLog.WriteLine(string.Format((IFormatProvider)null, "Comparative BVT : Successfully validated the File Path '{0}'.", filePath)); using (FastASequencePositionParser parser = new FastASequencePositionParser(filePath)) { IEnumerable<ISequence> referenceList = parser.Parse(); foreach (ISequence seq in referenceList) { referenceSeqList.Add(seq); } // Gets the query sequence from the FastA file string queryFilePath = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode2); Assert.IsNotNull(queryFilePath); ApplicationLog.WriteLine(string.Format((IFormatProvider)null, "Comparative BVT : Successfully validated the File Path '{0}'.", queryFilePath)); using (FastASequencePositionParser queryParser = new FastASequencePositionParser(queryFilePath)) { IEnumerable<ISequence> querySeqList = queryParser.Parse(); foreach (ISequence seq in querySeqList) { searchSeqList.Add(seq); } } } } else { // Gets the reference & search sequences from the configurtion file referenceSequences = utilityObj.xmlUtil.GetTextValues(nodeName, Constants.ReferenceSequencesNode); searchSequences = utilityObj.xmlUtil.GetTextValues(nodeName, Constants.SearchSequencesNode); IAlphabet seqAlphabet = Utility.GetAlphabet(utilityObj.xmlUtil.GetTextValue(nodeName, Constants.AlphabetNameNode)); for (int i = 0; i < referenceSequences.Length; i++) { ISequence referSeq = new Sequence(seqAlphabet, encodingObj.GetBytes(referenceSequences[i])); referenceSeqList.Add(referSeq); } string[] seqArray = searchSequences.ElementAt(0).Split(','); searchSeqList.AddRange(seqArray.Select(t => new Sequence(seqAlphabet, encodingObj.GetBytes(t))).Cast<ISequence>()); } foreach (ISequence reference in referenceSeqList) { NUCmer nucmerAligner = new NUCmer((Sequence)reference); string fixedSeparation = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FixedSeparationNode); string minimumScore = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.MinimumScoreNode); string separationFactor = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.SeparationFactorNode); string LengthOfMUM = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.MUMLengthNode); nucmerAligner.FixedSeparation = int.Parse(fixedSeparation); nucmerAligner.MinimumScore = int.Parse(minimumScore); nucmerAligner.SeparationFactor = int.Parse(separationFactor); nucmerAligner.LengthOfMUM = int.Parse(LengthOfMUM); foreach (ISequence querySeq in searchSeqList) { results.Add(nucmerAligner.GetDeltaAlignments(querySeq, true)); } } return results; }
/// <summary> /// Validates Assemble method .Step 1-5. /// </summary> /// <param name="nodeName">Parent Node name in Xml</param> public void ValidateComparativeAssembleMethod(string nodeName) { ComparativeGenomeAssembler assemble = new ComparativeGenomeAssembler(); List<ISequence> referenceSeqList; StringBuilder expectedSequence = new StringBuilder(utilityObj.xmlUtil.GetTextValue(nodeName, Constants.ExpectedSequenceNode)); string LengthOfMUM = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.MUMLengthNode); string kmerLength = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.KmerLengthNode); string fixedSeparation = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FixedSeparationNode); string minimumScore = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.MinimumScoreNode); string separationFactor = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.SeparationFactorNode); string maximumSeparation = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.MaximumSeparationNode); string breakLength = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.BreakLengthNode); // Gets the reference sequence from the FastA file string filePath = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode1); Assert.IsNotNull(filePath); ApplicationLog.WriteLine(string.Format(null, "Comparative BVT : Successfully validated the File Path '{0}'.", filePath)); using (FastAParser parser = new FastAParser(filePath)) { IEnumerable<ISequence> referenceList = parser.Parse(); Assert.IsNotNull(referenceList); referenceSeqList = new List<ISequence>(referenceList); } // Get the reads from configuration file. string readFilePath = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode2); assemble.LengthOfMum = int.Parse(LengthOfMUM, CultureInfo.InvariantCulture); assemble.KmerLength = int.Parse(kmerLength, CultureInfo.InvariantCulture); assemble.ScaffoldingEnabled = true; assemble.FixedSeparation = int.Parse(fixedSeparation, CultureInfo.InvariantCulture); assemble.MinimumScore = int.Parse(minimumScore, CultureInfo.InvariantCulture); assemble.SeparationFactor = float.Parse(separationFactor, CultureInfo.InvariantCulture); assemble.MaximumSeparation = int.Parse(maximumSeparation, CultureInfo.InvariantCulture); assemble.BreakLength = int.Parse(breakLength, CultureInfo.InvariantCulture); using (var queryparser = new FastASequencePositionParser(readFilePath)) { IEnumerable<ISequence> output = assemble.Assemble(referenceSeqList, queryparser); StringBuilder longOutput = new StringBuilder(); foreach (string x in output.Select(seq => seq.ConvertToString()).OrderBy(c => c)) longOutput.Append(x); Assert.AreEqual(expectedSequence.ToString().ToUpperInvariant(), longOutput.ToString().ToUpperInvariant()); } }