/// <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());
}
}
