/// <summary>
/// Get chromoses with orphan regions
/// </summary>
/// <param name="filename">Path of the BAM file</param>
/// <param name="mean">Mean value</param>
/// <param name="deviation">Standard deviation</param>
/// <returns></returns>
private void DisplayOrphans(string filename)
{
SequenceAlignmentMap alignmentMapobj = null;
if (!SAMInput)
{
BAMParser bamParser = new BAMParser();
alignmentMapobj = bamParser.ParseOne<SequenceAlignmentMap>(filename);
}
else
{
SAMParser samParser = new SAMParser();
alignmentMapobj = samParser.ParseOne<SequenceAlignmentMap>(filename);
}
// get reads from sequence alignment map object.
IList<PairedRead> pairedReads = null;
// Get Aligned sequences
IList<SAMAlignedSequence> alignedSeqs = alignmentMapobj.QuerySequences;
pairedReads = alignmentMapobj.GetPairedReads(0, 0);
// Get the orphan regions.
var orphans = pairedReads.Where(PR => PR.PairedType == PairedReadType.Orphan);
int count = orphans.Count();
if (count == 0)
{
Console.WriteLine("No Orphans to display");
}
var orphanRegions = new List<ISequenceRange>(count);
orphanRegions.AddRange(orphans.Select(orphanRead => GetRegion(orphanRead.Read1)));
// Get sequence range grouping object.
SequenceRangeGrouping rangeGroup = new SequenceRangeGrouping(orphanRegions);
if (!rangeGroup.GroupIDs.Any())
{
Console.Write("\r\nNo Orphan reads to display");
}
else
{
Console.Write("Region of Orphan reads:");
DisplaySequenceRange(rangeGroup);
}
SequenceRangeGrouping mergedRegions = rangeGroup.MergeOverlaps();
if (!mergedRegions.GroupIDs.Any())
{
Console.Write("\r\nNo hot spots to display");
}
else
{
Console.Write("\r\nChromosomal hot spot:");
DisplaySequenceRange(mergedRegions);
}
}
public void TestFormatter()
{
const string filePath = @"TestUtils\BAM\SeqAlignment.bam";
const string outputfilePath = "BAMTests123.bam";
string outputIndexFile = outputfilePath + ".bai";
BAMParser parser = new BAMParser();
SequenceAlignmentMap alignmentMap = parser.ParseOne<SequenceAlignmentMap>(filePath);
Assert.IsNotNull(alignmentMap);
Assert.IsNotNull(alignmentMap.Header);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.IsNotNull(alignmentMap.QuerySequences);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
BAMFormatter formatter = new BAMFormatter();
formatter.Format(alignmentMap, outputfilePath);
formatter.CreateSortedBAMFile = true;
formatter.CreateIndexFile = true;
formatter.Format(alignmentMap, outputfilePath);
Assert.IsTrue(File.Exists("BAMTests123.bam.bai"));
alignmentMap = parser.ParseOne<SequenceAlignmentMap>(outputfilePath);
Assert.IsNotNull(alignmentMap);
Assert.IsNotNull(alignmentMap.Header);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
alignmentMap = parser.ParseRange("BAMTests123.bam", new SequenceRange("chr20", 0, int.MaxValue));
Assert.IsNotNull(alignmentMap);
Assert.IsNotNull(alignmentMap.Header);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
alignmentMap = parser.ParseRange("BAMTests123.bam", new SequenceRange("chr20", 0, 28833));
Assert.IsNotNull(alignmentMap);
Assert.IsNotNull(alignmentMap.Header);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 1);
File.Delete(outputfilePath);
File.Delete(outputIndexFile);
}
/// <summary>
/// Get Chimera data
/// </summary>
/// <param name="filename">Path of the BAM file</param>
/// <param name="mean">Mean value</param>
/// <param name="deviation">Standard deviation</param>
/// <returns></returns>
private Matrix<string, string, string> GetChimeraData(string filename)
{
SequenceAlignmentMap alignmentMapobj = null;
if (!SAMInput)
{
BAMParser bamParser = new BAMParser();
alignmentMapobj = bamParser.ParseOne<SequenceAlignmentMap>(filename);
}
else
{
SAMParser samParser = new SAMParser();
alignmentMapobj = samParser.ParseOne<SequenceAlignmentMap>(filename);
}
// get reads from sequence alignment map object.
IList<PairedRead> pairedReads = null;
pairedReads = alignmentMapobj.GetPairedReads(200, 50);
// select chimeras from reads.
var chimeras = pairedReads.Where(PE => PE.PairedType == PairedReadType.Chimera);
// Group chimeras based on first reads chromosomes name.
var groupedChimeras =
chimeras.GroupBy(PR => PR.Read1.RName);
IList<string> chrs = alignmentMapobj.GetRefSequences();
// Declare sparse matrix to store statistics.
SparseMatrix<string, string, string> statistics =
SparseMatrix<string, string, string>.CreateEmptyInstance(
chrs, chrs, "0");
// For each group create sub group depending on the second reads chromosomes.
foreach (var group in groupedChimeras)
{
foreach (var subgroup in group.GroupBy(PE => PE.Read2.RName))
{
// store the count to stats
statistics[group.Key, subgroup.Key] = subgroup.Count().ToString();
}
}
return statistics;
}
/// <summary>
/// Display Sequence Item occurences percentage
/// </summary>
/// <param name="inputFile">Path of the input file</param>
/// <param name="possibleOccurence">True to display Nculeaotide distribution</param>
public void DisplaySequenceItemOccurences(string inputFile,
bool possibleOccurence)
{
if (string.IsNullOrEmpty(inputFile))
{
throw new InvalidOperationException("Input File Not specified");
}
SequenceAlignmentMap alignmentMapobj = null;
if (!SAMInput)
{
BAMParser bamParser = new BAMParser();
alignmentMapobj = bamParser.ParseOne<SequenceAlignmentMap>(inputFile);
}
else
{
SAMParser samParser = new SAMParser();
alignmentMapobj = samParser.ParseOne<SequenceAlignmentMap>(inputFile);
}
IList<string> chromosomes = alignmentMapobj.GetRefSequences();
if (possibleOccurence)
{
Console.Write("Nucleotide Distribution:");
Console.Write("\r\nPosition\tA\tT\tG\tC\tPossibility Of Occurences");
foreach (string str in chromosomes)
{
GetCoverage(str, alignmentMapobj, "true");
}
}
else
{
Console.Write("Coverage Profile:");
Console.Write("\r\nPosition\tA\tT\tG\tC");
foreach (string str in chromosomes)
{
GetCoverage(str, alignmentMapobj, "false");
}
}
}
public void TestParser()
{
const string FilePath = @"TestUtils\BAM\SeqAlignment.bam";
BAMParser parser = null;
try
{
parser = new BAMParser();
SequenceAlignmentMap alignmentMap = parser.ParseOne<SequenceAlignmentMap>(FilePath);
Assert.IsTrue(alignmentMap != null);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
}
finally
{
if (parser != null)
parser.Dispose();
}
}
/// <summary>
/// Public method to sort BAM file.
/// SAMUtil.exe in.bam out.bam
/// </summary>
public void DoSort()
{
string sortExtension = ".sort";
if (string.IsNullOrEmpty(InputFilename))
{
throw new InvalidOperationException(Resources.SortHelp);
}
BAMParser parse = new BAMParser();
SequenceAlignmentMap map = null;
try
{
map = parse.ParseOne<SequenceAlignmentMap>(InputFilename);
}
catch(Exception ex)
{
throw new InvalidOperationException(Resources.InvalidBAMFile, ex);
}
BAMFormatter format = new BAMFormatter
{
CreateSortedBAMFile = true,
SortType =
this.SortByReadName
? BAMSortByFields.ReadNames
: BAMSortByFields.ChromosomeCoordinates
};
if (string.IsNullOrEmpty(OutputFilename))
{
OutputFilename = InputFilename + sortExtension;
autoGeneratedOutputFilename = true;
}
format.Format(map, OutputFilename);
if (autoGeneratedOutputFilename)
{
Console.WriteLine(Resources.SuccessMessageWithOutputFileName, OutputFilename);
}
}
/// <summary>
/// Parse BAM and validate parsed aligned sequences and its properties.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Parse method parameters</param>
/// <param name="IsEncoding">
/// True for BAMParser ctor with encoding.
/// False otherwise
/// </param>
private void ValidateBAMParser(string nodeName,
BAMParserParameters BAMParserPam,
bool IsReferenceIndex)
{
// Get input and output values from xml node.
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string refIndexValue = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.RefIndexNode);
string startIndexValue = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.StartIndexNode);
string endIndexValue = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.EndIndexNode);
string alignedSeqCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
string refSeqName = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ChromosomeNameNode);
SequenceAlignmentMap seqAlignment = null;
BAMParser bamParser = null;
try
{
bamParser = new BAMParser();
// Parse a BAM file with different parameters.
switch (BAMParserPam)
{
case BAMParserParameters.StreamReader:
using (Stream stream = new FileStream(bamFilePath, FileMode.Open,
FileAccess.Read))
{
seqAlignment = bamParser.ParseOne(stream);
}
break;
case BAMParserParameters.FileName:
seqAlignment = bamParser.ParseOne<SequenceAlignmentMap>(bamFilePath);
break;
case BAMParserParameters.ParseRangeFileName:
seqAlignment = bamParser.ParseRange(bamFilePath,
Convert.ToInt32(refIndexValue, null));
break;
case BAMParserParameters.ParseRangeWithIndex:
seqAlignment = bamParser.ParseRange(bamFilePath,
Convert.ToInt32(refIndexValue, null),
Convert.ToInt32(startIndexValue, null),
Convert.ToInt32(endIndexValue, null));
break;
case BAMParserParameters.ParseRangeUsingRefSeq:
seqAlignment = bamParser.ParseRange(bamFilePath, refSeqName);
break;
case BAMParserParameters.ParseRangeUsingRefSeqAndFlag:
seqAlignment = bamParser.ParseRange(bamFilePath, refSeqName);
break;
case BAMParserParameters.ParseRangeUsingRefSeqUsingIndex:
seqAlignment = bamParser.ParseRange(bamFilePath, refSeqName,
Convert.ToInt32(startIndexValue, null),
Convert.ToInt32(endIndexValue, null));
break;
case BAMParserParameters.ParseRangeUsingIndexesAndFlag:
seqAlignment = bamParser.ParseRange(bamFilePath, refSeqName,
Convert.ToInt32(startIndexValue, null),
Convert.ToInt32(endIndexValue, null));
break;
}
// Validate BAM Header record fileds.
if (!IsReferenceIndex)
{
this.ValidateBAMHeaderRecords(nodeName, seqAlignment);
}
IList<SAMAlignedSequence> alignedSeqs = seqAlignment.QuerySequences;
Assert.AreEqual(alignedSeqCount, alignedSeqs.Count.ToString((IFormatProvider) null));
// Get expected sequences
var parserObj = new FastAParser();
{
IEnumerable<ISequence> expectedSequences = parserObj.Parse(expectedAlignedSeqFilePath);
IList<ISequence> expectedSequencesList = expectedSequences.ToList();
// Validate aligned sequences from BAM file.
for (int index = 0; index < alignedSeqs.Count; index++)
{
Assert.IsFalse(alignedSeqs[index].IsDummyRead);
Assert.AreEqual(
new string(expectedSequencesList[index].Select(a => (char) a).ToArray()),
new string(alignedSeqs[index].QuerySequence.Select(a => (char) a).ToArray()));
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser BVT : Validated Aligned sequence :{0} successfully",
alignedSeqs[index].QuerySequence));
}
}
}
finally
{
bamParser.Dispose();
}
}
public void ValidateSortByChromosomeNameAndCoordinates()
{
using (var parser = new BAMParser())
{
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(Constants.MediumSizeBAMFileNode,
Constants.FilePathNode);
Assert.IsNotNull(bamFilePath);
SequenceAlignmentMap seqAlignment = parser.ParseOne<SequenceAlignmentMap>(bamFilePath);
this.ValidateSort(seqAlignment, BAMSortByFields.ChromosomeNameAndCoordinates);
}
}
public void ValidateSAMToBAMConversion()
{
// Get values from xml config file.
string expectedBamFilePath = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMToSAMConversionNode, Constants.FilePathNode);
string samFilePath = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMToSAMConversionNode, Constants.FilePathNode1);
// Parse expected BAM file.
var bamParserObj = new BAMParser();
SequenceAlignmentMap expextedBamAlignmentObj = bamParserObj.ParseOne<SequenceAlignmentMap>(expectedBamFilePath);
// Parse a SAM file.
var samParserObj = new SAMParser();
SequenceAlignmentMap samSeqAlignment = samParserObj.ParseOne<SequenceAlignmentMap>(samFilePath);
try
{
// Format SAM sequenceAlignment object to BAM file.
var bamFormatterObj = new BAMFormatter();
bamFormatterObj.Format(samSeqAlignment, Constants.BAMTempFileName);
// Parse a formatted BAM file.
SequenceAlignmentMap bamSeqAlignment = bamParserObj.ParseOne<SequenceAlignmentMap>(Constants.BAMTempFileName);
// Validate converted BAM file with expected BAM file.
Assert.IsTrue(CompareSequencedAlignmentHeader(bamSeqAlignment, expextedBamAlignmentObj));
// Validate BAM file aligned sequences.
Assert.IsTrue(CompareAlignedSequences(bamSeqAlignment, expextedBamAlignmentObj));
}
finally
{
// Delete temporary file.
File.Delete(Constants.BAMTempFileName);
}
}
public void ValidateGetInsertLengthWithValidate()
{
// Get input and output values from xml node.
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(Constants.PairedReadTypesForLibraryInfoNode,
Constants.FilePathNode);
string mean = this.utilityObj.xmlUtil.GetTextValue(
Constants.PairedReadTypesForLibraryInfoNode, Constants.MeanNode);
string deviation = this.utilityObj.xmlUtil.GetTextValue(
Constants.PairedReadTypesForLibraryInfoNode, Constants.DeviationValueNode);
string[] insertLength = this.utilityObj.xmlUtil.GetTextValue(
Constants.PairedReadTypesForLibraryInfoNode, Constants.InsertLengthNode).Split(',');
using (var bamParser = new BAMParser())
{
SequenceAlignmentMap seqAlignmentMapObj = bamParser.ParseOne<SequenceAlignmentMap>(bamFilePath);
int i = 0;
try
{
IList<PairedRead> pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
foreach (PairedRead read in pairedReads)
{
//pass true for validate parameter
int length = PairedRead.GetInsertLength(read.Read1, read.Read2, true);
Assert.AreEqual(length.ToString((IFormatProvider) null), insertLength[i]);
i++;
}
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser BVT : Validated GetInsertLength Successfully"));
}
finally
{
bamParser.Dispose();
}
}
}
public void ValidateSortByReadNames()
{
using (var parser = new BAMParser())
{
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(Constants.MediumSizeBAMFileNode,
Constants.FilePathNode);
SequenceAlignmentMap seqAlignment = parser.ParseOne<SequenceAlignmentMap>(bamFilePath);
this.ValidateSort(seqAlignment, BAMSortByFields.ReadNames);
}
}
/// <summary>
/// Validate different paired read types
/// </summary>
/// <param name="nodeName">XML node name</param>
/// <param name="pams">GetPairedReadTypes method parameters</param>
private void ValidatePairedReadTypes(string nodeName, GetPairedReadTypeParameters pams)
{
// Get input and output values from xml node.
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string mean = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.MeanNode);
string deviation = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.DeviationValueNode);
string library = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.LibraryNameNode);
string[] pairedReadType = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.PairedReadTypeNode).Split(',');
string[] insertLength = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.InsertLengthNode).Split(',');
var bamParser = new BAMParser();
SequenceAlignmentMap seqAlignmentMapObj = bamParser.ParseOne<SequenceAlignmentMap>(bamFilePath);
CloneLibraryInformation libraryInfo;
int i = 0;
try
{
IList<PairedRead> pairedReads;
switch (pams)
{
case GetPairedReadTypeParameters.PaireReadTypeUsingLibraryName:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
foreach (PairedRead read in pairedReads)
{
PairedReadType type = PairedRead.GetPairedReadType(read, library);
Assert.AreEqual(type.ToString(), pairedReadType[i]);
i++;
}
break;
case GetPairedReadTypeParameters.PaireReadTypeUsingCloneLibraryInfo:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
libraryInfo = CloneLibrary.Instance.GetLibraryInformation(library);
foreach (PairedRead read in pairedReads)
{
PairedReadType type = PairedRead.GetPairedReadType(read, libraryInfo);
Assert.AreEqual(type.ToString(), pairedReadType[i]);
i++;
}
break;
case GetPairedReadTypeParameters.PaireReadTypeUsingMeanAndDeviation:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
foreach (PairedRead read in pairedReads)
{
PairedReadType type = PairedRead.GetPairedReadType(read, float.Parse(mean, null),
float.Parse(deviation, null));
Assert.AreEqual(type.ToString(), pairedReadType[i]);
i++;
}
break;
case GetPairedReadTypeParameters.PaireReadTypeUsingReadsAndLibrary:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
foreach (PairedRead read in pairedReads)
{
PairedReadType type = PairedRead.GetPairedReadType(read.Read1,
read.Read2, library);
Assert.AreEqual(type.ToString(), pairedReadType[i]);
i++;
}
break;
case GetPairedReadTypeParameters.PaireReadTypeUsingReadsAndLibraryInfo:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
libraryInfo = CloneLibrary.Instance.GetLibraryInformation(library);
foreach (PairedRead read in pairedReads)
{
PairedReadType type = PairedRead.GetPairedReadType(read.Read1,
read.Read2, libraryInfo);
Assert.AreEqual(type.ToString(), pairedReadType[i]);
i++;
}
break;
case GetPairedReadTypeParameters.GetInsertLength:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
libraryInfo = CloneLibrary.Instance.GetLibraryInformation(library);
foreach (PairedRead read in pairedReads)
{
int length = PairedRead.GetInsertLength(read.Read1, read.Read2);
Assert.AreEqual(length.ToString((IFormatProvider) null), insertLength[i]);
i++;
}
break;
}
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser BVT : Validated Paired read Type Successfully"));
}
finally
{
bamParser.Dispose();
}
}
public void ValidateBAMParserWithDummyReads()
{
string bamFilePath = utilityObj.xmlUtil.GetTextValue(Constants.BAMFileWithDummyReads,
Constants.FilePathNode);
SequenceAlignmentMap seqAlignment = null;
BAMParser bamParser = null;
bamParser = new BAMParser();
seqAlignment = bamParser.ParseOne<SequenceAlignmentMap>(bamFilePath);
var seq = seqAlignment.QuerySequences.First();
Assert.AreEqual("fakeref", seq.RName);
Assert.AreEqual("1M", seq.CIGAR);
Assert.AreEqual(10, seq.Pos);
Assert.IsNull(seq.QuerySequence);
var optField = seq.OptionalFields.First();
Assert.AreEqual("CT", optField.Tag);
Assert.AreEqual("Z", optField.VType);
Assert.AreEqual(".;ESDN;", optField.Value);
Assert.IsTrue(seq.IsDummyRead);
}
/// <summary>
/// Validate SAM to BAM conversion.
/// </summary>
/// <param name="nodeName">Different xml node name used for different test cases</param>
void ValidateSAMToBAMConversion(string nodeName)
{
// Get values from xml config file.
string expectedBAMStoragePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string samFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode1);
BAMParser bamParserObj = new BAMParser();
SAMParser samParserObj = new SAMParser();
BAMFormatter bamFormatterObj = new BAMFormatter { CreateSortedBAMFile = true, CreateIndexFile = true };
SequenceAlignmentMap samSeqAlignment = null;
SequenceAlignmentMap bamSeqAlignment = null;
// Parse expected BAM file.
SequenceAlignmentMap expextedBamAlignmentObj = bamParserObj.ParseOne<SequenceAlignmentMap>(expectedBAMStoragePath);
// Parse a SAM file.
samSeqAlignment = samParserObj.ParseOne<SequenceAlignmentMap>(samFilePath);
try
{
// Format SAM sequenceAlignment object to BAM file.
bamFormatterObj.Format(samSeqAlignment, Constants.BAMTempFileName);
// Parse a formatted BAM file.
bamSeqAlignment = bamParserObj.ParseOne<SequenceAlignmentMap>(Constants.BAMTempFileName);
// Validate converted BAM file with expected BAM file.
Assert.IsTrue(CompareSequencedAlignmentHeader(bamSeqAlignment,
expextedBamAlignmentObj));
// Validate BAM file aligned sequences.
Assert.IsTrue(CompareAlignedSequences(bamSeqAlignment,
expextedBamAlignmentObj));
// Log message to VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser P1 : Validated the SAM->BAM conversion successfully"));
}
finally
{
// Delete temporary file.
File.Delete(Constants.BAMTempFileName);
ApplicationLog.WriteLine("Deleted the temp file created.");
}
}
/// <summary>
/// Validate GetPaired method
/// </summary>
/// <param name="nodeName">XML node name</param>
/// <param name="pams">GetPairedReads method parameters</param>
private void ValidatePairedReads(string nodeName, GetPairedReadParameters pams)
{
// Get input and output values from xml node.
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string mean = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.MeanNode);
string deviation = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.DeviationValueNode);
string library = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.LibraryNameNode);
string pairedReadsCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.PairedReadsNode);
string[] insertLength = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.InsertLengthNode).Split(',');
string[] pairedReadType = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.PairedReadTypeNode).Split(',');
SequenceAlignmentMap seqAlignment = null;
IList<PairedRead> pairedReads = null;
var bamParser = new BAMParser();
var parserObj = new FastAParser();
try
{
seqAlignment = bamParser.ParseOne<SequenceAlignmentMap>(bamFilePath);
IEnumerable<ISequence> expectedSequences = parserObj.Parse(expectedAlignedSeqFilePath);
switch (pams)
{
case GetPairedReadParameters.GetPairedReadWithParameters:
pairedReads = seqAlignment.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, 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 VSTest GUI.
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser BVT : Validated Paired read :{0} successfully",
seq.QuerySequence));
}
i++;
}
}
finally
{
bamParser.Dispose();
}
}
public void TestFormatterWithSort()
{
string inputFilePath = @"TestUtils\BAM\SeqAlignment.bam";
string outputFilePath1 = "output1.bam";
string outputFilePath2 = "output2.bam";
BAMParser parser = null;
try
{
parser = new BAMParser();
BAMFormatter formatter = new BAMFormatter();
SequenceAlignmentMap alignmentMap = parser.ParseOne<SequenceAlignmentMap>(inputFilePath);
Assert.IsTrue(alignmentMap != null);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
formatter.CreateSortedBAMFile = true;
formatter.SortType = BAMSortByFields.ChromosomeCoordinates;
formatter.Format(alignmentMap, outputFilePath1);
alignmentMap = parser.ParseOne<SequenceAlignmentMap>(inputFilePath);
formatter.Format(alignmentMap, outputFilePath2);
Assert.IsTrue(File.Exists(outputFilePath1));
Assert.IsTrue(File.Exists(outputFilePath2));
Assert.AreEqual(true, FileCompare(outputFilePath1, outputFilePath2));
}
finally
{
if (parser != null)
parser.Dispose();
File.Delete(outputFilePath1);
File.Delete(outputFilePath2);
}
}
/// <summary>
/// Validate formatted BAM file.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Format method parameters</param>
private void ValidateBAMFormatter(string nodeName,
BAMParserParameters BAMParserPam)
{
// Get input and output values from xml node.
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string alignedSeqCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
using (var bamParserObj = new BAMParser())
{
// Parse a BAM file.
var seqAlignment = bamParserObj.ParseOne<SequenceAlignmentMap>(bamFilePath);
// Create a BAM formatter object.
var formatterObj = new BAMFormatter();
// Write/Format aligned sequences to BAM file.
switch (BAMParserPam)
{
case BAMParserParameters.StreamWriter:
Stream stream;
using (stream = new FileStream(Constants.BAMTempFileName, FileMode.Create, FileAccess.Write))
{
formatterObj.Format(stream, seqAlignment);
}
break;
case BAMParserParameters.FileName:
formatterObj.Format(seqAlignment, Constants.BAMTempFileName);
break;
case BAMParserParameters.IndexFile:
formatterObj.Format(seqAlignment, Constants.BAMTempFileName, Constants.BAMTempIndexFile);
File.Exists(Constants.BAMTempIndexFile);
break;
default:
break;
}
// Parse formatted BAM file and validate aligned sequences.
SequenceAlignmentMap expectedSeqAlignmentMap = bamParserObj.ParseOne<SequenceAlignmentMap>(Constants.BAMTempFileName);
// Validate Parsed BAM file Header record fileds.
this.ValidateBAMHeaderRecords(nodeName, expectedSeqAlignmentMap);
IList<SAMAlignedSequence> alignedSeqs = expectedSeqAlignmentMap.QuerySequences;
Assert.AreEqual(alignedSeqCount, alignedSeqs.Count.ToString((IFormatProvider) null));
// Get expected sequences
var parserObj = new FastAParser();
{
IEnumerable<ISequence> expectedSequences = parserObj.Parse(expectedAlignedSeqFilePath);
IList<ISequence> expectedSequencesList = expectedSequences.ToList();
// Validate aligned sequences from BAM file.
for (int index = 0; index < alignedSeqs.Count; index++)
{
Assert.AreEqual(
new string(expectedSequencesList[index].Select(a => (char) a).ToArray()),
new string(alignedSeqs[index].QuerySequence.Select(a => (char) a).ToArray()));
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format("BAM Formatter BVT : Validated Aligned sequence :{0} successfully", alignedSeqs[index].QuerySequence));
}
}
}
File.Delete(Constants.BAMTempFileName);
File.Delete(Constants.BAMTempIndexFile);
}
/// <summary>
/// Merge multiple sorted alignments.
/// SAMUtil.exe out.bam in1.bam in2.bam
/// </summary>
public void DoMerge()
{
if (FilePaths == null)
{
throw new InvalidOperationException("FilePath");
}
if (FilePaths.Length < 2)
{
throw new InvalidOperationException(Resources.MergeHelp);
}
IList<IList<BAMSortedIndex>> sortedIndexes = new List<IList<BAMSortedIndex>>();
IList<SequenceAlignmentMap> sequenceAlignmentMaps = new List<SequenceAlignmentMap>();
Parallel.For(0, FilePaths.Length, (int index) =>
{
IList<BAMSortedIndex> sortedIndex;
BAMParser parser = new BAMParser(); ;
SequenceAlignmentMap map;
if (index == 0)
{
try
{
map = parser.ParseOne<SequenceAlignmentMap>(FilePaths[0]);
}
catch
{
throw new InvalidOperationException(Resources.InvalidBAMFile);
}
if (map == null)
{
throw new InvalidOperationException(Resources.EmptyFile);
}
if (string.IsNullOrEmpty(HeaderFile) && map.Header.RecordFields.Count == 0)
{
throw new InvalidOperationException(Resources.HeaderMissing);
}
if (!string.IsNullOrEmpty(HeaderFile))
{
SAMParser parse = new SAMParser();
SequenceAlignmentMap head;
try
{
head = parse.ParseOne<SequenceAlignmentMap>(HeaderFile);
}
catch
{
throw new InvalidOperationException(Resources.IncorrectHeaderFile);
}
if (head == null)
{
throw new InvalidOperationException(Resources.EmptyFile);
}
header = head.Header;
}
else
{
header = map.Header;
}
sortedIndex = Sort(map, SortByReadName ? BAMSortByFields.ReadNames : BAMSortByFields.ChromosomeCoordinates);
}
else
{
try
{
map = parser.ParseOne<SequenceAlignmentMap>(FilePaths[index]);
}
catch
{
throw new InvalidOperationException(Resources.InvalidBAMFile);
}
if (map == null)
{
throw new InvalidOperationException(Resources.EmptyFile);
}
sortedIndex = Sort(map, SortByReadName ? BAMSortByFields.ReadNames : BAMSortByFields.ChromosomeCoordinates);
}
lock (sortedIndexes)
{
sortedIndexes.Add(sortedIndex);
sequenceAlignmentMaps.Add(map);
}
});
if (string.IsNullOrEmpty(OutputFilename))
{
OutputFilename = "out.bam";
autoGeneratedOutputFilename = true;
}
string filePath = Path.GetTempFileName();
using (FileStream fstemp = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite))
{
BAMFormatter formatter = new BAMFormatter();
formatter.WriteHeader(header, fstemp);
if (SortByReadName)
{
IList<BAMSortedIndex> sortedIndex = sortedIndexes.Select(a => a.First()).ToList();
WriteMergeFileSortedByReadName(sortedIndex, fstemp, formatter, sequenceAlignmentMaps);
}
else
{
WriteMergeFile(sortedIndexes, fstemp, formatter, sequenceAlignmentMaps);
}
using (FileStream fsoutput = new FileStream(OutputFilename, FileMode.Create, FileAccess.Write))
{
fstemp.Seek(0, SeekOrigin.Begin);
formatter.CompressBAMFile(fstemp, fsoutput);
}
}
File.Delete(filePath);
if (autoGeneratedOutputFilename)
{
Console.WriteLine(Properties.Resources.SuccessMessageWithOutputFileName, OutputFilename);
}
}
/// <summary>
/// Parse BAM and validate parsed aligned sequences by creating
/// ISequenceAlignment interface object and its properties.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Parse method parameters</param>
void ValidateISequenceAlignmentBAMParser(string nodeName,
BAMParserParameters BAMParserPam)
{
// Get input and output values from xml node.
string BAMStoragePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
IEnumerable<ISequenceAlignment> seqAlignmentList = null;
ISequenceAlignmentParser bamParser = null;
ISequenceAlignment seqAlignment = null;
IList<IAlignedSequence> alignedSeqs = null;
bamParser = new BAMParser();
// Parse a BAM file with different parameters.
switch (BAMParserPam)
{
case BAMParserParameters.FileName:
seqAlignmentList = bamParser.Parse(BAMStoragePath);
alignedSeqs = seqAlignmentList.First().AlignedSequences;
break;
case BAMParserParameters.ParseOne:
seqAlignment = bamParser.ParseOne(File.OpenRead(BAMStoragePath));
alignedSeqs = seqAlignment.AlignedSequences;
break;
default:
break;
}
// Get expected sequences
FastAParser parserObj = new FastAParser();
IEnumerable<ISequence> expectedSequences = parserObj.Parse(expectedAlignedSeqFilePath);
IList<ISequence> expectedSequencesList = expectedSequences.ToList();
// Validate aligned sequences from BAM file.
for (int index = 0; index < alignedSeqs.Count; index++)
{
Assert.AreEqual(new string(expectedSequencesList[index].Select(a => (char)a).ToArray()),
new string(alignedSeqs[index].Sequences[0].Select(a => (char)a).ToArray()));
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser P1 : Validated Aligned sequence :{0} successfully",
alignedSeqs[index].Sequences.ToString()));
}
}
/// <summary>
/// Format BAM file using IsequenceAlignment object.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Format method parameters</param>
/// <param name="WriteBAMIndexData">True if writting BAM index data to BAMIndex file,
/// false otherwise</param>
/// <param name="IsNotSupportedMethods">True if validating notsuportedMethods,
/// false otherwise</param>
void ValidateBAMFormatterWithSequenceAlignment(string nodeName,
BAMParserParameters BAMParserPam, bool WriteBAMIndexData,
bool IsNotSupportedMethods)
{
// Get input and output values from xml node.
string BAMStoragePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string alignedSeqCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
BAMIndexStorage BAMIndexStorageObj = null;
ISequenceAlignmentParser bamParserObj = new BAMParser();
try
{
using (BAMParser bamSeqMapParserObj = new BAMParser())
{
IEnumerable<ISequenceAlignment> seqList = bamParserObj.Parse(BAMStoragePath);
try
{
// Write BAm index data to BAM Index File.
if (WriteBAMIndexData)
{
BAMIndexStorageObj = new BAMIndexStorage(
File.Create(Constants.BAMTempIndexFileForSequenceAlignment));
}
// Create a BAM formatter object.
BAMFormatter formatterObj = new BAMFormatter
{
CreateSortedBAMFile = true,
CreateIndexFile = true
};
// Write/Format aligned sequences to BAM file.
switch (BAMParserPam)
{
case BAMParserParameters.StreamWriter:
try
{
using (var writer = File.Create(Constants.BAMTempFileName))
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(writer, seq);
Assert.Fail();
}
}
}
catch (NotSupportedException ex)
{
string message = ex.Message;
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Formatter P1 : Validated the exception {0} successfully"
, message));
}
break;
case BAMParserParameters.Stream:
using (Stream stream = new
FileStream(Constants.BAMTempFileName,
FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(stream, seq);
}
}
File.Exists(Constants.BAMTempFileName);
break;
case BAMParserParameters.FileName:
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(seq, Constants.BAMTempFileName);
}
File.Exists(Constants.BAMTempFileName);
break;
case BAMParserParameters.StreamAndIndexFile:
using (Stream stream = new
FileStream(Constants.BAMTempFileName,
FileMode.Create, FileAccess.ReadWrite))
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(stream, BAMIndexStorageObj, seq);
}
}
File.Exists(Constants.BAMTempFileName);
break;
case BAMParserParameters.IndexFile:
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(seq, Constants.BAMTempFileName,
Constants.BAMTempIndexFile);
}
File.Exists(Constants.BAMTempFileName);
break;
default:
break;
}
if (!IsNotSupportedMethods)
{
// Parse formatted BAM file and validate aligned sequences.
SequenceAlignmentMap expectedSeqAlignmentMap = bamSeqMapParserObj.ParseOne<SequenceAlignmentMap>(
Constants.BAMTempFileName);
IList<SAMAlignedSequence> alignedSeqs = expectedSeqAlignmentMap.QuerySequences;
Assert.AreEqual(alignedSeqCount, alignedSeqs.Count.ToString((IFormatProvider)null));
// Get expected sequences
FastAParser parserObj = new FastAParser();
IEnumerable<ISequence> expectedSequences = parserObj.Parse(expectedAlignedSeqFilePath);
IList<ISequence> expectedSequencesList = expectedSequences.ToList();
// Validate aligned sequences from BAM file.
for (int index = 0; index < alignedSeqs.Count; index++)
{
Assert.AreEqual(new string(expectedSequencesList[index].Select(a => (char)a).ToArray()),
new string(alignedSeqs[index].QuerySequence.Select(a => (char)a).ToArray()));
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Formatter P1 : Validated Aligned sequence :{0} successfully",
alignedSeqs[index].QuerySequence.ToString()));
}
}
}
finally
{
if (BAMIndexStorageObj != null)
BAMIndexStorageObj.Dispose();
}
}
}
finally
{
(bamParserObj as BAMParser).Dispose();
File.Delete(Constants.BAMTempFileName);
File.Delete(Constants.BAMTempIndexFile);
}
}
/// <summary>
/// Format BAM file and validate.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
private void InValidateBAMFormatter(string nodeName)
{
// Get input and output values from xml node.
string bamFilePath = _utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode);
using (var bamParserObj = new BAMParser())
{
using (var storage = new BAMIndexStorage(File.Create(Constants.BAMTempIndexFileForIndexData)))
{
// Parse a BAM file.
var seqAlignment = bamParserObj.ParseOne <SequenceAlignmentMap>(bamFilePath);
// Create a BAM formatter object.
var formatterObj = new BAMFormatter();
// Null filename
try
{
formatterObj.Format(seqAlignment, null, Constants.BAMTempIndexFileForIndexData);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Same filename
try
{
formatterObj.Format(seqAlignment, Constants.BAMTempFileName, Constants.BAMTempFileName);
}
catch (ArgumentException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Null sequence
try
{
formatterObj.Format(null, bamFilePath, Constants.BAMTempIndexFileForIndexData);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Null index
try
{
formatterObj.Format(seqAlignment, bamFilePath, null);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Invalidate BAM Parser Format(SeqAlignmentMap, BamFileName)
try
{
formatterObj.Format(null as SequenceAlignmentMap,
Constants.BAMTempFileName);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
try
{
formatterObj.Format(seqAlignment, null as string);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Invalidate Format(SequenceAlignmentMap, StreamWriter)
try
{
formatterObj.Format(null, seqAlignment);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
Stream stream;
try
{
using (stream = new FileStream(Constants.BAMTempFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
formatterObj.Format(stream, null as ISequenceAlignment);
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Invalidate Format(SequenceAlignmentMap, StreamWriter, IndexFile)
try
{
formatterObj.Format(null, storage, seqAlignment);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
try
{
using (stream = new FileStream(Constants.BAMTempFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
formatterObj.Format(stream, storage, null);
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
try
{
using (stream = new FileStream(Constants.BAMTempFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
formatterObj.Format(stream, null, seqAlignment);
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
formatterObj = null;
}
}
}
/// <summary>
/// Parse BAM File and Invalidate parsed aligned sequences by creating
/// ISequenceAlignment interface object and its properties.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Parse method parameters</param>
private void InValidateISequenceAlignmentBAMParser(string nodeName,
BAMParserParameters BAMParserPam)
{
// Get input and output values from xml node.
string bamFilePath = _utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string exception = string.Empty;
ISequenceAlignmentParser bamParser = null;
bamParser = new BAMParser();
try
{
// Parse a BAM file with different invalid parameters.
switch (BAMParserPam)
{
case BAMParserParameters.Stream:
try
{
using (var reader = File.OpenRead(bamFilePath))
{
bamParser.Parse(reader);
Assert.Fail();
}
}
catch (NotSupportedException ex)
{
exception = ex.Message;
}
break;
case BAMParserParameters.ParseOneStream:
try
{
using (var reader = File.OpenRead(bamFilePath))
{
bamParser.ParseOne(reader);
Assert.Fail();
}
}
catch (NotSupportedException ex)
{
exception = ex.Message;
}
break;
default:
break;
}
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser P2 : Validated Exception {0} successfully",
exception));
}
finally
{
(bamParser as BAMParser).Dispose();
}
}
public void ValidateAlignedSeqProperties()
{
// Get input and output values from xml node.
string BAMStoragePath = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMAlignedSeqPropertiesNode, Constants.FilePathNode);
string expectedFlagValue = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMAlignedSeqPropertiesNode, Constants.FlagValueNode);
string expectedISize = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMAlignedSeqPropertiesNode, Constants.Isize);
string expectedMapQ = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMAlignedSeqPropertiesNode, Constants.MapQValue);
string expectedMetadataCount = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMAlignedSeqPropertiesNode, Constants.Metadata);
string expectedMPos = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMAlignedSeqPropertiesNode, Constants.MPos);
string expectedOptionalFields = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMAlignedSeqPropertiesNode, Constants.OptionalFieldsNode);
string expectedPos = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMAlignedSeqPropertiesNode, Constants.Pos);
string expectedQueryLength = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMAlignedSeqPropertiesNode, Constants.QueryLength);
string expectedRName = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMAlignedSeqPropertiesNode, Constants.RName);
// Parse a BAM file.
using (BAMParser bamParseObj = new BAMParser())
{
BAMFormatter bamFormatterObj = new BAMFormatter();
SequenceAlignmentMap seqAlignment = bamParseObj.ParseOne<SequenceAlignmentMap>(BAMStoragePath);
// Get Aligned sequences.
IList<SAMAlignedSequence> alignedSeqs = seqAlignment.QuerySequences;
// Validate BAM Formatter Properties.
Assert.AreEqual(Constants.BAMFileName, bamFormatterObj.Name);
Assert.AreEqual(Constants.BAMFileType, bamFormatterObj.SupportedFileTypes);
Assert.AreEqual(Constants.BAMFormatterDescription,
bamFormatterObj.Description.Replace("\r", "").Replace("\n", ""));
// Validate BAM Parser Properties.
Assert.AreEqual(Constants.BAMFileName, bamParseObj.Name);
Assert.AreEqual(Constants.BAMFileType, bamParseObj.SupportedFileTypes);
Assert.AreEqual(Constants.BAMDescription,
bamParseObj.Description.Replace("\r", "").Replace("\n", ""));
// Validate all properties of aligned sequence.
Assert.AreEqual(expectedFlagValue, alignedSeqs[0].Flag.ToString());
Assert.AreEqual(expectedISize, alignedSeqs[0].ISize.ToString((IFormatProvider)null));
Assert.AreEqual(expectedMapQ, alignedSeqs[0].MapQ.ToString((IFormatProvider)null));
Assert.AreEqual(expectedMetadataCount,
alignedSeqs[0].Metadata.Count.ToString((IFormatProvider)null));
Assert.AreEqual(expectedMPos, alignedSeqs[0].MPos.ToString((IFormatProvider)null));
Assert.AreEqual(expectedOptionalFields,
alignedSeqs[0].OptionalFields.Count.ToString((IFormatProvider)null));
Assert.AreEqual(expectedPos, alignedSeqs[0].Pos.ToString((IFormatProvider)null));
Assert.AreEqual(expectedQueryLength,
alignedSeqs[0].RefEndPos.ToString((IFormatProvider)null));
Assert.AreEqual(expectedRName, alignedSeqs[0].RName.ToString((IFormatProvider)null));
}
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser P1 : Validated the Aligned sequence properties successfully"));
}
/// <summary>
/// Parse BAM and validate parsed aligned sequences and its properties.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">Different Parser parameters used for different testcases</param>
void ValidateBAMParserForQualitySequences(string nodeName,
BAMParserParameters BAMParserPam)
{
// Get input and output values from xml node.
string BAMStoragePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedQualitySeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string alignedSeqCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
SequenceAlignmentMap seqAlignment = null;
BAMParser bamParser = new BAMParser();
// Parse a BAM file with different parameters.
switch (BAMParserPam)
{
case BAMParserParameters.FileName:
seqAlignment = bamParser.ParseOne<SequenceAlignmentMap>(BAMStoragePath);
break;
case BAMParserParameters.StreamReader:
using (Stream stream = new FileStream(BAMStoragePath, FileMode.Open,
FileAccess.Read))
{
seqAlignment = bamParser.ParseOne(stream);
}
break;
default:
break;
}
// Validate Aligned sequence CIGAR,QName and Bin index values.
this.ValidateAlignedSeqValues(nodeName, seqAlignment);
IList<SAMAlignedSequence> alignedSeqs = seqAlignment.QuerySequences;
Assert.AreEqual(alignedSeqCount, alignedSeqs.Count.ToString((IFormatProvider)null));
// Get expected quality sequences
FastAParser parserObj = new FastAParser();
IEnumerable<ISequence> expectedQualitySequences = parserObj.Parse(expectedQualitySeqFilePath);
IList<ISequence> expectedSequencesList = expectedQualitySequences.ToList();
// Validate quality sequences from BAM file.
for (int index = 0; index < alignedSeqs.Count; index++)
{
Assert.AreEqual(new string(expectedSequencesList[index].Select(a => (char)a).ToArray()),
new string(alignedSeqs[index].QuerySequence.Select(a => (char)a).ToArray()));
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser P1 : Validated Quality sequence :{0} successfully",
alignedSeqs[index].QuerySequence.ToString()));
}
}
/// <summary>
/// Parses SAM/BAm file based on input file.
/// </summary>
private void PerformParse()
{
string samExtension = ".sam";
string bamExtension = ".bam";
if (Helper.IsBAM(InputFilename))
{
BAMParser parser = new BAMParser();
try
{
_sequenceAlignmentMap = parser.ParseOne<SequenceAlignmentMap>(InputFilename);
}
catch (Exception ex)
{
throw new InvalidOperationException(Resources.InvalidBAMFile, ex);
}
if (string.IsNullOrEmpty(OutputFilename))
{
OutputFilename = InputFilename + samExtension;
}
}
else
{
SAMParser parser = new SAMParser();
try
{
_sequenceAlignmentMap = parser.ParseOne<SequenceAlignmentMap>(InputFilename);
}
catch (Exception ex)
{
throw new InvalidOperationException(Resources.InvalidSAMFile, ex);
}
_isSAM = true;
if (string.IsNullOrEmpty(OutputFilename))
{
OutputFilename = InputFilename + bamExtension;
}
}
}
/// <summary>
/// Indentify hot spot chromosomes for length anamoly regions.
/// </summary>
/// <param name="inputFile"> Input file</param>
/// <param name="mean">Mean value</param>
/// <param name="standardDeviation">Standard deviation</param>
private void IdentifyLentghAnamolies(string filename,
float mean = -1, float deviation = -1)
{
bool calculateMeanNdeviation = false;
if (mean == -1 || deviation == -1)
{
calculateMeanNdeviation = true;
}
SequenceAlignmentMap alignmentMapobj = null;
if (!SAMInput)
{
BAMParser bamParser = new BAMParser();
alignmentMapobj = bamParser.ParseOne<SequenceAlignmentMap>(filename);
}
else
{
SAMParser samParser = new SAMParser();
alignmentMapobj = samParser.ParseOne<SequenceAlignmentMap>(filename);
}
// get reads from sequence alignment map object.
IList<PairedRead> pairedReads = null;
if (calculateMeanNdeviation)
{
pairedReads = alignmentMapobj.GetPairedReads();
}
else
{
pairedReads = alignmentMapobj.GetPairedReads(mean, deviation);
}
// Get the orphan regions.
var orphans = pairedReads.Where(PR => PR.PairedType == PairedReadType.Orphan);
if (orphans.Count() == 0)
{
Console.WriteLine("No Orphans to display");
}
List<ISequenceRange> orphanRegions = new List<ISequenceRange>(orphans.Count());
foreach (PairedRead orphanRead in orphans)
{
orphanRegions.Add(GetRegion(orphanRead.Read1));
}
// Get sequence range grouping for Orphan regions.
SequenceRangeGrouping orphanRangegroup = new SequenceRangeGrouping(orphanRegions);
// Get the Length anomalies regions.
var lengthAnomalies = pairedReads.Where(PE => PE.PairedType == PairedReadType.LengthAnomaly);
if (lengthAnomalies.Count() == 0)
{
Console.WriteLine("No Anomalies to display");
}
List<ISequenceRange> lengthAnomalyRegions = new List<ISequenceRange>(lengthAnomalies.Count());
foreach (PairedRead laRead in lengthAnomalies)
{
SequenceRange range = new SequenceRange();
range.ID = laRead.Read1.RName;
range.Start = laRead.Read1.Pos;
range.End = laRead.Read1.Pos + laRead.InsertLength;
lengthAnomalyRegions.Add(range);
}
// Get sequence range grouping for length anomaly regions.
SequenceRangeGrouping lengthAnomalyRangegroup =
new SequenceRangeGrouping(lengthAnomalyRegions);
if (lengthAnomalyRangegroup.GroupIDs.Count() == 0)
{
Console.Write("\r\nNo Length anomalies reads to display");
}
else
{
Console.Write("Region of length anomaly:");
DisplaySequenceRange(lengthAnomalyRangegroup);
}
if (orphanRangegroup.GroupIDs.Count() == 0)
{
Console.Write("\r\nNo Orphan reads to display");
}
else
{
Console.Write("\r\nRegion of Orphan reads:");
DisplaySequenceRange(orphanRangegroup);
}
SequenceRangeGrouping intersectedRegions =
lengthAnomalyRangegroup.Intersect(orphanRangegroup);
if (intersectedRegions.GroupIDs.Count() == 0)
{
Console.Write("\r\nNo Hot spots found");
}
else
{
Console.Write("\r\nChromosomal Hot spot of length anomaly and Orphan region:");
DisplaySequenceRange(intersectedRegions);
}
}
