/// <summary>
/// Gets the paired reads.
/// </summary>
/// <param name="libraryInfo">Library information.</param>
/// <returns>List of paired read.</returns>
public IList <PairedRead> GetPairedReads(CloneLibraryInformation libraryInfo)
{
if (libraryInfo == null)
{
throw new ArgumentNullException("libraryInfo");
}
return(GetPairedReads(libraryInfo.MeanLengthOfInsert, libraryInfo.StandardDeviationOfInsert));
}
/// <summary>
/// Override Equals method
/// </summary>
/// <param name="obj">Input Object</param>
/// <returns>Result of comparison</returns>
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return(false);
}
CloneLibraryInformation info = (CloneLibraryInformation)obj;
return((LibraryName == info.LibraryName) && (MeanLengthOfInsert == info.MeanLengthOfInsert) &&
(StandardDeviationOfInsert == info.StandardDeviationOfInsert));
}
public void ValidateLibraryName()
{
CloneLibraryInformation cloneLibrary = new CloneLibraryInformation();
string libraryName = this.utilityObj.xmlUtil.GetTextValue(
Constants.CloneLibraryInformationNode, Constants.LibraryNameNode);
cloneLibrary.LibraryName = libraryName;
Assert.AreEqual(libraryName, cloneLibrary.LibraryName);
ApplicationLog.WriteLine(string.Concat("CloneLibraryInformation BVT: Validation of Public property: Library Name",
cloneLibrary.LibraryName, " completed successfully."));
}
/// <summary>
/// Gets the paired reads type.
/// </summary>
/// <param name="pairedRead">Paired read.</param>
/// <param name="libraryInfo">Library information.</param>
/// <param name="useInsertLengthOfReads">
/// If this flag is set to true then insert length will be calculated from read1 and read2,
/// else InsertLength in spcified paired read will be used.
/// </param>
public static PairedReadType GetPairedReadType(PairedRead pairedRead, CloneLibraryInformation libraryInfo, bool useInsertLengthOfReads)
{
if (pairedRead == null)
{
throw new ArgumentNullException("pairedRead");
}
if (libraryInfo == null)
{
throw new ArgumentNullException("libraryInfo");
}
return(GetPairedReadType(pairedRead, libraryInfo.MeanLengthOfInsert, libraryInfo.StandardDeviationOfInsert, useInsertLengthOfReads));
}
public void ValidateInEqualityOfTwoClones()
{
CloneLibraryInformation cloneLibrary1 = new CloneLibraryInformation();
CloneLibraryInformation cloneLibrary2 = new CloneLibraryInformation();
string libraryName = this.utilityObj.xmlUtil.GetTextValue(
Constants.CloneLibraryInformationNode, Constants.LibraryNameNode);
cloneLibrary1.LibraryName = libraryName;
cloneLibrary2.LibraryName = libraryName + "newValue";
Assert.IsFalse(cloneLibrary1.Equals(cloneLibrary2));
ApplicationLog.WriteLine(string.Concat("CloneLibraryInformation BVT: Validation of Overridden method: Not Equals",
cloneLibrary2.LibraryName, " completed successfully."));
}
/// <summary>
/// Gets the paired reads type.
/// </summary>
/// <param name="read1">First aligned sequence.</param>
/// <param name="read2">Second aligned sequence.</param>
/// <param name="libraryName">library name.</param>
public static PairedReadType GetPairedReadType(SAMAlignedSequence read1, SAMAlignedSequence read2, string libraryName)
{
if (string.IsNullOrEmpty(libraryName))
{
throw new ArgumentNullException("libraryName");
}
CloneLibraryInformation libraryInfo = CloneLibrary.Instance.GetLibraryInformation(libraryName);
if (libraryInfo == null)
{
throw new ArgumentOutOfRangeException("libraryName");
}
return(GetPairedReadType(read1, read2, libraryInfo));
}
/// <summary>
/// Selection change event of library combo.
/// </summary>
/// <param name="sender">Sender object.</param>
/// <param name="e">Selection Chnaged EventArgs.</param>
private void OnLibraryNames_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (!e.AddedItems[0].ToString().Equals("Add New Library"))
{
CloneLibraryInformation information = CloneLibrary.Instance.GetLibraryInformation(e.AddedItems[0].ToString());
this.txtLibraryMean.Text = information.MeanLengthOfInsert.ToString();
this.txtLibraryName.Text = information.LibraryName.ToString();
this.txtLibraryStandardDeviation.Text = information.StandardDeviationOfInsert.ToString();
}
else
{
this.txtLibraryMean.Text = string.Empty;
this.txtLibraryName.Text = string.Empty;
this.txtLibraryStandardDeviation.Text = string.Empty;
}
}
/// <summary>
/// Gets the paired reads.
/// </summary>
/// <param name="libraryName">Name of the library present in CloneLibrary.</param>
/// <returns>List of paired read.</returns>
public IList <PairedRead> GetPairedReads(string libraryName)
{
if (string.IsNullOrEmpty(libraryName))
{
throw new ArgumentNullException("libraryName");
}
CloneLibraryInformation libraryInfo = CloneLibrary.Instance.GetLibraryInformation(libraryName);
if (libraryInfo == null)
{
throw new ArgumentOutOfRangeException("libraryName");
}
return(GetPairedReads(libraryInfo));
}
/// <summary>
/// Gets the paired reads type.
/// </summary>
/// <param name="pairedRead">Paired read.</param>
/// <param name="libraryName">library name.</param>
/// <param name="useInsertLengthOfReads">
/// If this flag is set to true then insert length will be calculated from read1 and read2,
/// else InsertLength in spcified paired read will be used.
/// </param>
public static PairedReadType GetPairedReadType(PairedRead pairedRead, string libraryName, bool useInsertLengthOfReads)
{
if (pairedRead == null)
{
throw new ArgumentNullException("pairedRead");
}
if (string.IsNullOrEmpty(libraryName))
{
throw new ArgumentNullException("libraryName");
}
CloneLibraryInformation libraryInfo = CloneLibrary.Instance.GetLibraryInformation(libraryName);
if (libraryInfo == null)
{
throw new ArgumentOutOfRangeException("libraryName");
}
return(GetPairedReadType(pairedRead, libraryInfo, useInsertLengthOfReads));
}
/// <summary>
/// Resolve repeats between two sets of deltas coming from paired reads
/// </summary>
/// <param name="curReadDeltas">Deltas from a read</param>
/// <param name="mateDeltas">Deltas from mate pair</param>
/// <returns>Selected delta out of all given deltas</returns>
private static List <DeltaAlignment> ResolveRepeatUsingMatePair(List <DeltaAlignment> curReadDeltas, List <DeltaAlignment> mateDeltas, string libraryName)
{
// Check if all mate pairs are completly aligned, else return null (cannot resolve)
if (mateDeltas.Any(a =>
{
return(a.SecondSequenceEnd != a.QuerySequence.Count - 1);
}))
{
return(null);
}
// Get clone library information
CloneLibraryInformation libraryInfo = CloneLibrary.Instance.GetLibraryInformation(libraryName);
float mean = libraryInfo.MeanLengthOfInsert;
float stdDeviation = libraryInfo.StandardDeviationOfInsert;
// Find delta with a matching distance.
for (int indexFR = 0; indexFR < curReadDeltas.Count; indexFR++)
{
DeltaAlignment pair1 = curReadDeltas[indexFR];
for (int indexRR = 0; indexRR < mateDeltas.Count; indexRR++)
{
DeltaAlignment pair2 = mateDeltas[indexRR];
long distance = Math.Abs(pair1.FirstSequenceStart - pair2.FirstSequenceEnd);
// Find delta with matching distance.
if (distance - mean <= stdDeviation)
{
List <DeltaAlignment> resolvedDeltas = new List <DeltaAlignment>(2);
resolvedDeltas.Add(pair1);
resolvedDeltas.Add(pair2);
return(resolvedDeltas);
}
}
}
return(null);
}
/// <summary>
/// Resolve repeats between two sets of deltas coming from paired reads
/// </summary>
/// <param name="curReadDeltas">Deltas from a read</param>
/// <param name="mateDeltas">Deltas from mate pair</param>
/// <returns>Selected delta out of all given deltas</returns>
private static List <DeltaAlignment> ResolveRepeatUsingMatePair(IEnumerable <DeltaAlignment> curReadDeltas, IEnumerable <DeltaAlignment> mateDeltas)
{
// Check if all mate pairs are completly aligned, else return null (cannot resolve)
if (mateDeltas.Any(a =>
{
return(a.SecondSequenceEnd != a.QuerySequence.Count - 1);
}))
{
return(null);
}
// Get clone library information
string libraryName = curReadDeltas.ElementAt(0).QuerySequence.ID.Split(':')[1];
CloneLibraryInformation libraryInfo = CloneLibrary.Instance.GetLibraryInformation(libraryName);
float mean = libraryInfo.MeanLengthOfInsert;
float stdDeviation = libraryInfo.StandardDeviationOfInsert;
// Find delta with a matching distance.
foreach (DeltaAlignment pair1 in curReadDeltas)
{
foreach (DeltaAlignment pair2 in mateDeltas)
{
long distance = Math.Abs(pair1.FirstSequenceStart - pair2.FirstSequenceEnd);
// Find delta with matching distance.
if (distance - mean <= stdDeviation)
{
List <DeltaAlignment> resolvedDeltas = new List <DeltaAlignment>(2);
resolvedDeltas.Add(pair1);
resolvedDeltas.Add(pair2);
return(resolvedDeltas);
}
}
}
return(null);
}
/// <summary>
/// Gets the paired reads type.
/// </summary>
/// <param name="pairedRead">Paired read.</param>
/// <param name="libraryInfo">Library information.</param>
public static PairedReadType GetPairedReadType(PairedRead pairedRead, CloneLibraryInformation libraryInfo)
{
return(GetPairedReadType(pairedRead, libraryInfo, false));
}
/// <summary>
/// Validate Add library information in existing libraries.
/// </summary>
/// <param name="nodeName">xml node name used for different testcases</param>
/// <param name="IsLibraryInfo">Is library info?</param>
internal void AddLibraryInformation(string nodeName, bool IsLibraryInfo)
{
string filePath = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedPairedReadsCount = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.PairedReadsCountNode);
string[] backwardReadsNode = utilityObj.xmlUtil.GetTextValues(nodeName,
Constants.BackwardReadsNode);
string[] forwardReadsNode = utilityObj.xmlUtil.GetTextValues(nodeName,
Constants.ForwardReadsNode);
string expectedLibraray = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.LibraryName);
string expectedStdDeviation = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.StdDeviation);
string mean = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.Mean);
IList<ISequence> sequenceReads = new List<ISequence>();
IList<MatePair> pairedreads = new List<MatePair>();
// Get the input reads
IEnumerable<ISequence> sequences = null;
using (FastAParser parser = new FastAParser(filePath))
{
sequences = parser.Parse();
foreach (ISequence seq in sequences)
{
sequenceReads.Add(seq);
}
// Add a new library infomration.
if (IsLibraryInfo)
{
CloneLibraryInformation libraryInfo =
new CloneLibraryInformation();
libraryInfo.LibraryName = expectedLibraray;
libraryInfo.MeanLengthOfInsert = float.Parse(mean, (IFormatProvider)null);
libraryInfo.StandardDeviationOfInsert = float.Parse(expectedStdDeviation, (IFormatProvider)null);
CloneLibrary.Instance.AddLibrary(libraryInfo);
}
else
{
CloneLibrary.Instance.AddLibrary(expectedLibraray,
float.Parse(mean, (IFormatProvider)null), float.Parse(expectedStdDeviation, (IFormatProvider)null));
}
// Convert reads to map paired reads.
MatePairMapper pair = new MatePairMapper();
pairedreads = pair.Map(sequenceReads);
// Validate Map paired reads.
Assert.AreEqual(expectedPairedReadsCount, pairedreads.Count.ToString((IFormatProvider)null));
for (int index = 0; index < pairedreads.Count; index++)
{
Assert.IsTrue(forwardReadsNode.Contains(new string(pairedreads[index].GetForwardRead(sequenceReads).Select(a => (char)a).ToArray())));
Assert.IsTrue(backwardReadsNode.Contains(new string(pairedreads[index].GetReverseRead(sequenceReads).Select(a => (char)a).ToArray())));
Assert.AreEqual(expectedStdDeviation,
pairedreads[index].StandardDeviationOfLibrary.ToString((IFormatProvider)null));
Assert.AreEqual(expectedLibraray, pairedreads[index].Library.ToString((IFormatProvider)null));
Assert.AreEqual(mean, pairedreads[index].MeanLengthOfLibrary.ToString((IFormatProvider)null));
}
}
ApplicationLog.WriteLine(@"Padena P1 : Map paired reads has been verified successfully");
}
/// <summary>
/// Gets the paired reads type.
/// </summary>
/// <param name="pairedRead">Paired read.</param>
/// <param name="libraryInfo">Library information.</param>
public static PairedReadType GetPairedReadType(PairedRead pairedRead, CloneLibraryInformation libraryInfo)
{
return GetPairedReadType(pairedRead, libraryInfo, false);
}
/// <summary>
/// Gets the paired reads type.
/// </summary>
/// <param name="pairedRead">Paired read.</param>
/// <param name="libraryInfo">Library information.</param>
/// <param name="useInsertLengthOfReads">
/// If this flag is set to true then insert length will be calculated from read1 and read2,
/// else InsertLength in spcified paired read will be used.
/// </param>
public static PairedReadType GetPairedReadType(PairedRead pairedRead, CloneLibraryInformation libraryInfo, bool useInsertLengthOfReads)
{
if (pairedRead == null)
{
throw new ArgumentNullException("pairedRead");
}
if (libraryInfo == null)
{
throw new ArgumentNullException("libraryInfo");
}
return GetPairedReadType(pairedRead, libraryInfo.MeanLengthOfInsert, libraryInfo.StandardDeviationOfInsert, useInsertLengthOfReads);
}
/// <summary>
/// Gets the paired reads type.
/// </summary>
/// <param name="read1">First aligned sequence.</param>
/// <param name="read2">Second aligned sequence.</param>
/// <param name="libraryInfo">Library information.</param>
public static PairedReadType GetPairedReadType(SAMAlignedSequence read1, SAMAlignedSequence read2, CloneLibraryInformation libraryInfo)
{
if (libraryInfo == null)
{
throw new ArgumentNullException("libraryInfo");
}
return GetPairedReadType(read1, read2, libraryInfo.MeanLengthOfInsert, libraryInfo.StandardDeviationOfInsert);
}
/// <summary>
/// Validate GetPaired method
/// </summary>
/// <param name="nodeName">XML node name</param>
/// <param name="pams">GetPairedReads method parameters</param>
void ValidatePairedReads(string nodeName, GetPairedReadParameters pams)
{
// Get input and output values from xml node.
string bamFilePath = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string mean = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.MeanNode);
string deviation = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.DeviationValueNode);
string library = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.LibraryNameNode);
string pairedReadsCount = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.PairedReadsNode);
string[] insertLength = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.InsertLengthNode).Split(',');
string[] pairedReadType = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.PairedReadTypeNode).Split(',');
SequenceAlignmentMap seqAlignment = null;
IList <PairedRead> pairedReads = null;
BAMParser bamParser = new BAMParser();
FastAParser parserObj = new FastAParser(expectedAlignedSeqFilePath);
try
{
seqAlignment = bamParser.Parse(bamFilePath);
IEnumerable <ISequence> expectedSequences = parserObj.Parse();
switch (pams)
{
case GetPairedReadParameters.GetPairedReadWithParameters:
pairedReads = seqAlignment.GetPairedReads(float.Parse(mean, (IFormatProvider)null),
float.Parse(deviation, (IFormatProvider)null));
break;
case GetPairedReadParameters.GetPairedReadWithLibraryName:
pairedReads = seqAlignment.GetPairedReads(library);
break;
case GetPairedReadParameters.GetPairedReadWithCloneLibraryInfo:
CloneLibraryInformation libraryInfo =
CloneLibrary.Instance.GetLibraryInformation(library);
pairedReads = seqAlignment.GetPairedReads(libraryInfo);
break;
case GetPairedReadParameters.Default:
pairedReads = seqAlignment.GetPairedReads();
break;
}
Assert.AreEqual(pairedReadsCount, pairedReads.Count.ToString((IFormatProvider)null));
int i = 0;
foreach (PairedRead read in pairedReads)
{
Assert.AreEqual(insertLength[i], read.InsertLength.ToString((IFormatProvider)null));
Assert.AreEqual(pairedReadType[i], read.PairedType.ToString());
foreach (SAMAlignedSequence seq in read.Reads)
{
Assert.AreEqual(new string(expectedSequences.ElementAt(i).Select(a => (char)a).ToArray()),
new string(seq.QuerySequence.Select(a => (char)a).ToArray()));
// Log to NUNIT GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser BVT : Validated Paired read :{0} successfully",
seq.QuerySequence.ToString()));
}
i++;
}
}
finally
{
bamParser.Dispose();
}
}
/// <summary>
/// Gets the paired reads.
/// </summary>
/// <param name="libraryInfo">Library information.</param>
/// <returns>List of paired read.</returns>
public IList<PairedRead> GetPairedReads(CloneLibraryInformation libraryInfo)
{
if (libraryInfo == null)
{
throw new ArgumentNullException("libraryInfo");
}
return GetPairedReads(libraryInfo.MeanLengthOfInsert, libraryInfo.StandardDeviationOfInsert);
}
/// <summary>
/// Gets the paired reads type.
/// </summary>
/// <param name="read1">First aligned sequence.</param>
/// <param name="read2">Second aligned sequence.</param>
/// <param name="libraryInfo">Library information.</param>
public static PairedReadType GetPairedReadType(SAMAlignedSequence read1, SAMAlignedSequence read2, CloneLibraryInformation libraryInfo)
{
if (libraryInfo == null)
{
throw new ArgumentNullException("libraryInfo");
}
return(GetPairedReadType(read1, read2, libraryInfo.MeanLengthOfInsert, libraryInfo.StandardDeviationOfInsert));
}
/// <summary>
/// Validate ParallelDenovoAssembler class properties.
/// </summary>
/// <param name="nodeName">xml node name used for different testcases</param>
internal void ParallelDenovoAssemblyProperties(string nodeName)
{
// Get values from XML node.
string filePath = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode);
string kmerLength = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.KmerLengthNode);
string library = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.LibraryName);
string StdDeviation = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.StdDeviation);
string mean = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.Mean);
// Get the input reads and build kmers
IEnumerable<ISequence> sequenceReads = null;
using (FastAParser parser = new FastAParser(filePath))
{
sequenceReads = parser.Parse();
// Build kmers from step1,graph in step2
// Remove the dangling links from graph in step3
// Remove bubbles form the graph in step4
// Pass the graph and build contigs
// Validate the contigs
this.KmerLength = int.Parse(kmerLength, (IFormatProvider)null);
this.SequenceReads.Clear();
this.SetSequenceReads(sequenceReads.ToList());
this.CreateGraph();
this.UnDangleGraph();
this.RedundantPathsPurger =
new RedundantPathsPurger(int.Parse(kmerLength, (IFormatProvider)null) + 1);
this.RemoveRedundancy();
this.ContigBuilder = new SimplePathContigBuilder();
// Build contigs
IEnumerable<ISequence> contigs = this.BuildContigs();
CloneLibraryInformation cloneLibInfoObj = new CloneLibraryInformation();
cloneLibInfoObj.LibraryName = library;
cloneLibInfoObj.MeanLengthOfInsert = float.Parse(mean, (IFormatProvider)null);
cloneLibInfoObj.StandardDeviationOfInsert = float.Parse(StdDeviation, (IFormatProvider)null);
// Build scaffolds.
CloneLibrary.Instance.AddLibrary(library, float.Parse(mean, (IFormatProvider)null),
float.Parse(StdDeviation, (IFormatProvider)null));
IEnumerable<ISequence> scaffolds = BuildScaffolds(contigs.ToList());
PadenaAssembly denovoAssembly = new PadenaAssembly();
denovoAssembly.AddContigs(contigs);
denovoAssembly.AddScaffolds(scaffolds);
Assert.AreEqual(denovoAssembly.ContigSequences.Count(),
contigs.Count());
Assert.AreEqual(denovoAssembly.Scaffolds.Count(), scaffolds.Count());
Assert.IsNull(denovoAssembly.Documentation);
// Validates the Clone Library for the existing clone
CloneLibraryInformation actualObj = CloneLibrary.Instance.GetLibraryInformation(library);
Assert.IsTrue(actualObj.Equals(cloneLibInfoObj));
ApplicationLog.WriteLine("CloneLibraryInformation Equals() is successfully validated");
}
// Validate ParallelDenovoAssembler properties.
ApplicationLog.WriteLine(
@"Padena BVT : Validated ParallelDenovo Assembly properties");
}
