/// <summary> /// Writes sequence alignment to specified stream. /// </summary> /// <param name="sequenceAlignment">Sequence alignment object</param> /// <param name="writer">Stream to write.</param> /// <param name="indexFile">BAMIndex file.</param> private void WriteSequenceAlignment(ISequenceAlignment sequenceAlignment, Stream writer, BAMIndexFile indexFile) { // validate sequenceAlignment. SequenceAlignmentMap sequenceAlignmentMap = ValidateAlignment(sequenceAlignment); string tempFilename = Path.GetTempFileName(); // write bam struct to temp file. using (FileStream fstemp = new FileStream(tempFilename, FileMode.Create, FileAccess.ReadWrite)) { WriteUncompressed(sequenceAlignmentMap, fstemp); fstemp.Seek(0, SeekOrigin.Begin); // Compress and write to the specified stream. CompressBAMFile(fstemp, writer); // if index file need to be created. if (indexFile != null) { writer.Seek(0, SeekOrigin.Begin); CreateIndexFile(writer, indexFile); } } // delete the temp file. File.Delete(tempFilename); }
/// <summary> /// Write out the given SequenceAlignmentMap to the file /// </summary> /// <param name="formatter">BAMFormatter</param> /// <param name="sam">SequenceAlignmentMap</param> /// <param name="filename">File to write to</param> public static void Format(this BAMFormatter formatter, SequenceAlignmentMap sam, string filename) { if (formatter == null) { throw new ArgumentNullException("formatter"); } if (sam == null) { throw new ArgumentNullException("sam"); } if (string.IsNullOrWhiteSpace(filename)) { throw new ArgumentNullException("filename"); } using (var fs = File.Create(filename)) { // Create the IndexFile if necessary if (formatter.CreateIndexFile) { using (var bamIndexFile = new BAMIndexStorage( File.Create(filename + Properties.Resource.BAM_INDEXFILEEXTENSION))) { formatter.Format(fs, bamIndexFile, sam); } } else { formatter.Format(fs, sam); } } }
public void ValidateVirtualSAMAlignedSequenceListContains() { // Get values from XML node. string filePath = _utilityObj._xmlUtil.GetTextValue(Constants.SAMFileWithAllFieldsNode, Constants.FilePathNode1); // Parse a SAM file. using (SAMParser samParserObj = new SAMParser()) { samParserObj.EnforceDataVirtualization = true; SequenceAlignmentMap alignedSeqList = samParserObj.Parse(filePath); IList <SAMAlignedSequence> samAlignedList = alignedSeqList.QuerySequences; VirtualAlignedSequenceList <SAMAlignedSequence> virtualASeqList = GetSAMAlignedSequence(Constants.SAMFileWithAllFieldsNode); // Validate contains. Assert.IsTrue(virtualASeqList.Contains(virtualASeqList.First( Q => Q.QuerySequence.ToString().Equals( samAlignedList[0].QuerySequence.ToString())))); // Log to Nunit GUI. ApplicationLog.WriteLine(string.Format((IFormatProvider)null, "Virtual AlignedSequenceList P1 : VAS {0} is present in the virtualAlignedSequence List", virtualASeqList[10])); Console.WriteLine(string.Format((IFormatProvider)null, "Virtual AlignedSequenceList P1 : VAS {0} is present in the virtualAlignedSequence List", virtualASeqList[10])); } }
/// <summary> /// Writes specified alignment object to a file. The output is formatted according to the BAM specification. /// Also creates index file in the same location that of the specified filename. /// If the specified filename is sample.bam then the index file name will be sample.bam.bai. /// </summary> /// <param name="sequenceAlignmentMap">SequenceAlignmentMap object.</param> /// <param name="filename">BAM file name to write BAM data.</param> public void Format(SequenceAlignmentMap sequenceAlignmentMap, string filename) { if (sequenceAlignmentMap == null) { throw new ArgumentNullException("sequenceAlignmentMap"); } if (string.IsNullOrWhiteSpace(filename)) { throw new ArgumentNullException("filename"); } using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.ReadWrite)) { if (CreateIndexFile) { using (BAMIndexFile bamIndexFile = new BAMIndexFile(filename + Resource.BAM_INDEXFILEEXTENSION, FileMode.Create, FileAccess.Write)) { WriteSequenceAlignment(sequenceAlignmentMap, fs, bamIndexFile); } } else { WriteSequenceAlignment(sequenceAlignmentMap, fs, null); } } }
public void TestFormatterWithSort() { string inputFilePath = @"TestData\BAM\SeqAlignment.bam"; string outputFilePath1 = "output1.bam"; string outputFilePath2 = "output2.bam"; BAMParser parser = new BAMParser(); BAMFormatter formatter = new BAMFormatter(); SequenceAlignmentMap alignmentMap = parser.Parse(inputFilePath); Assert.IsTrue(alignmentMap != null); Assert.AreEqual(alignmentMap.Header.GetReferenceSequences().Count, 1); Assert.AreEqual(alignmentMap.QuerySequences.Count, 2); formatter.CreateSortedBAMFile = true; formatter.SortType = BAMSortByFields.ChromosomeCoordinates; formatter.Format(alignmentMap, outputFilePath1); parser.EnforceDataVirtualization = true; alignmentMap = parser.Parse(inputFilePath); formatter.Format(alignmentMap, outputFilePath2); Assert.IsTrue(File.Exists(outputFilePath1)); Assert.IsTrue(File.Exists(outputFilePath2)); Assert.AreEqual(true, FileCompare(outputFilePath1, outputFilePath2)); }
/// <summary> /// Dispalys the headers present in the BAM file /// </summary> /// <param name="seqAlignmentMap">SeqAlignment map</param> private void DisplayHeader(SequenceAlignmentMap seqAlignmentMap) { // Get Header SAMAlignmentHeader header = seqAlignmentMap.Header; IList <SAMRecordField> recordField = header.RecordFields; IList <string> commenstList = header.Comments; if (recordField.Count > 0) { Console.WriteLine("MetaData:"); // Read Header Lines for (int i = 0; i < recordField.Count; i++) { Console.Write("\n@{0}", recordField[i].Typecode); for (int tags = 0; tags < recordField[i].Tags.Count; tags++) { Console.Write("\t{0}:{1}", recordField[i].Tags[tags].Tag, recordField[i].Tags[tags].Value); } } } // Displays the comments if any if (commenstList.Count > 0) { for (int i = 0; i < commenstList.Count; i++) { Console.Write("\n@CO\t{0}\n", commenstList[i].ToString()); } } }
/// <summary> /// Writes specified alignment object to a file. /// The output is formatted according to the BAM specification. /// </summary> /// <param name="sequenceAlignmentMap">SequenceAlignmentMap object.</param> /// <param name="bamFilename">BAM filename to write BAM data.</param> /// <param name="indexFilename">BAM index filename to write index data.</param> public void Format(SequenceAlignmentMap sequenceAlignmentMap, string bamFilename, string indexFilename) { if (sequenceAlignmentMap == null) { throw new ArgumentNullException("sequenceAlignmentMap"); } if (string.IsNullOrWhiteSpace(bamFilename)) { throw new ArgumentNullException("bamFilename"); } if (string.IsNullOrWhiteSpace(indexFilename)) { throw new ArgumentNullException("indexFilename"); } if (bamFilename.Equals(indexFilename)) { throw new ArgumentException(Resource.BAM_BAMFileNIndexFileContbeSame); } using (FileStream fs = new FileStream(bamFilename, FileMode.Create, FileAccess.ReadWrite)) { using (BAMIndexFile bamIndexFile = new BAMIndexFile(indexFilename, FileMode.Create, FileAccess.Write)) { WriteSequenceAlignment(sequenceAlignmentMap, fs, bamIndexFile); } } }
/// <summary> /// Parse SAM or BAM file based on user input. /// </summary> private void DoParse() { if (!SAMInput) { BAMParser parse = new BAMParser(); parse.EnforceDataVirtualization = true; try { _seqAlignmentMap = parse.Parse(InputFilePath); } catch { throw new InvalidOperationException(Resources.InvalidBAMFile); } } else { SAMParser parse = new SAMParser(); parse.EnforceDataVirtualization = true; try { _seqAlignmentMap = parse.Parse(InputFilePath); } catch { throw new InvalidOperationException(Resources.InvalidSAMFile); } } }
/// <summary> /// Writes specified sequence alignment to stream. /// The output is formatted according to the BAM structure. /// </summary> /// <param name="sequenceAlignmentMap">SequenceAlignmentMap object.</param> /// <param name="writer">Stream to write.</param> /// <param name="createSortedFile">If this flag is true output file will be sorted.</param> private void WriteUncompressed(SequenceAlignmentMap sequenceAlignmentMap, Stream writer, bool createSortedFile) { SAMAlignmentHeader header = sequenceAlignmentMap.Header; if (createSortedFile && SortType == BAMSortByFields.ChromosomeNameAndCoordinates) { header = GetHeaderWithSortedSQFields(header, true); this.refSequences = header.GetReferenceSequenceRanges(); } if (this.refSequences == null) { this.refSequences = header.GetReferenceSequenceRanges(); } WriteHeader(header, writer); writer.Flush(); if (createSortedFile) { WriteUncompressedSortedBAM(sequenceAlignmentMap, writer); } else { foreach (SAMAlignedSequence seq in sequenceAlignmentMap.QuerySequences) { SAMAlignedSequence alignedSeq = seq; this.ValidateSQHeader(alignedSeq.RName); this.WriteAlignedSequence(alignedSeq, writer); writer.Flush(); } } writer.Flush(); }
/// <summary> /// Compare two SAM objects /// </summary> /// <param name="map">First SAM object.</param> /// <param name="map1">Second DAM object.</param> /// <returns>Whether two objects are equal or not.</returns> private static bool CompareSAM(SequenceAlignmentMap map, SequenceAlignmentMap map1) { bool comparison = false; if (map.Header.RecordFields.Count == map1.Header.RecordFields.Count && map.Header.Comments.Count == map1.Header.Comments.Count) { if (map.Header.RecordFields.All( a => map1.Header.RecordFields.Where( b => a.Tags.All( c => b.Tags.Where( d => c.Tag.Equals(d.Tag) && c.Value.Equals(d.Value)).ToList().Count > 0)).ToList().Count > 0)) { if (map.QuerySequences.Count == map1.QuerySequences.Count) { if (map.QuerySequences.AsParallel().All(e => map1.QuerySequences.Where(f => e.Bin == f.Bin && e.CIGAR == f.CIGAR).ToList().Count > 0)) { comparison = true; } } } } return(comparison); }
/// <summary> /// Validate BAM file Header fields. /// </summary> /// <param name="nodeName">XML nodename used for different test cases</param> /// <param name="seqAlignment">seqAlignment object</param> void ValidateBAMHeaderRecords(string nodeName, SequenceAlignmentMap seqAlignment) { string expectedHeaderTagValues = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.RecordTagValuesNode); string expectedHeaderTagKeys = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.RecordTagKeysNode); string expectedHeaderTypes = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.HeaderTyepsNodes); string[] expectedHeaderTagsValues = expectedHeaderTagValues.Split(','); string[] expectedHeaderKeys = expectedHeaderTagKeys.Split(','); string[] expectedHeaders = expectedHeaderTypes.Split(','); SAMAlignmentHeader header = seqAlignment.Header; IList <SAMRecordField> recordFields = header.RecordFields; int tagKeysCount = 0; int tagValuesCount = 0; for (int index = 0; index < recordFields.Count; index++) { Assert.AreEqual(expectedHeaders[index].Replace("/", ""), recordFields[index].Typecode.ToString((IFormatProvider)null).Replace("/", "")); for (int tags = 0; tags < recordFields[index].Tags.Count; tags++) { Assert.AreEqual(expectedHeaderKeys[tagKeysCount].Replace("/", ""), recordFields[index].Tags[tags].Tag.ToString((IFormatProvider)null).Replace("/", "")); Assert.AreEqual(expectedHeaderTagsValues[tagValuesCount].Replace("/", ""), recordFields[index].Tags[tags].Value.ToString((IFormatProvider)null).Replace("/", "").Replace("\r", "").Replace("\n", "")); tagKeysCount++; tagValuesCount++; } } }
/// <summary> /// General method to validate SAM parser method. /// </summary> /// <param name="nodeName">xml node name</param> /// <param name="parseTypes">enum type to execute different overload</param> void ValidateSAMParser(string nodeName) { // Gets the expected sequence from the Xml string filePath = Utility._xmlUtil.GetTextValue( nodeName, Constants.FilePathNode); string expectedSequenceFile = Utility._xmlUtil.GetTextValue( nodeName, Constants.ExpectedSequence); SAMParser parser = new SAMParser(); SequenceAlignmentMap alignments = null; // Parse SAM File using (TextReader reader = new StreamReader(filePath)) { alignments = parser.Parse(reader); } // Get expected sequences FastaParser parserObj = new FastaParser(); IList <ISequence> expectedSequences = parserObj.Parse(expectedSequenceFile); // Validate parsed output with expected output for (int index = 0; index < alignments.QuerySequences.Count; index++) { for (int count = 0; count < alignments.QuerySequences[index].Sequences.Count; count++) { Assert.AreEqual(expectedSequences[index].ToString(), alignments.QuerySequences[index].Sequences[count].ToString()); } } }
public void PerformBAMParserPerf() { // Get BAM file path. string bamFilePath = Utility._xmlUtil.GetTextValue(Constants.BAMParserNode, Constants.FilePathNode); // Create a List for input files. List <string> lstInputFiles = new List <string>(); lstInputFiles.Add(bamFilePath); // Create a BAM Parser object BAMParser parseBam = new BAMParser(); // Enable DV. parseBam.EnforceDataVirtualization = true; _watchObj = new Stopwatch(); _watchObj.Reset(); _watchObj.Start(); long memoryStart = GC.GetTotalMemory(false); SequenceAlignmentMap align = parseBam.Parse(bamFilePath); _watchObj.Stop(); long memoryEnd = GC.GetTotalMemory(false); string memoryUsed = (memoryEnd - memoryStart).ToString(); // Display BAMParser perf test case execution details. DisplayTestCaseHeader(lstInputFiles, _watchObj, memoryUsed, null); }
public void TestSNPDetectionUsingBAMFile() { using (BAMParser parser = new BAMParser()) { SequenceAlignmentMap map = parser.Parse(@"TestUtils\BAM\PairedReadsTest.bam"); TestCoverage("chr1", map, "true"); } }
public void TestCoverageProfileUsingSAMFile() { using (SAMParser parser = new SAMParser()) { SequenceAlignmentMap map = parser.Parse(@"TestUtils\SAM\PairedReadsTest.sam"); TestCoverage("chr1", map, "true"); } }
public void ValidateSAMParserWithEmptyAlignmentMap() { SAMParser parser = new SAMParser(); { SequenceAlignmentMap alignment = parser.ParseOne <SequenceAlignmentMap>(utilityObj.xmlUtil.GetTextValue(Constants.EmptySamFileNode, Constants.FilePathNode)); Assert.IsNotNull(alignment); } }
/// <summary> /// General method to validate SAM Formatter method. /// </summary> /// <param name="nodeName">xml node name</param> /// <param name="parseTypes">enum type to execute different overload</param> void ValidateSAMFormatterSeqAlign( string nodeName, ParseOrFormatTypes parseTypes) { // Gets the expected sequence from the Xml string filePath = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.FilePathNode); string expectedSequenceFile = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.ExpectedSequence); using (SAMParser parser = new SAMParser()) { SequenceAlignmentMap alignments = parser.Parse(filePath); SAMFormatter formatter = new SAMFormatter(); switch (parseTypes) { case ParseOrFormatTypes.ParseOrFormatText: using (TextWriter writer = new StreamWriter(Constants.SAMTempFileName)) { formatter.Format(alignments, writer); } break; case ParseOrFormatTypes.ParseOrFormatFileName: formatter.Format(alignments, Constants.SAMTempFileName); break; case ParseOrFormatTypes.ParseOrFormatFileNameWithFlag: formatter.Format(alignments, Constants.SAMTempFileName); break; } alignments = parser.Parse(Constants.SAMTempFileName); // Get expected sequences using (FastaParser parserObj = new FastaParser()) { IList <ISequence> expectedSequences = parserObj.Parse(expectedSequenceFile); // Validate parsed output with expected output for (int index = 0; index < alignments.QuerySequences.Count; index++) { for (int count = 0; count < alignments.QuerySequences[index].Sequences.Count; count++) { Assert.AreEqual(expectedSequences[index].ToString(), alignments.QuerySequences[index].Sequences[count].ToString()); } } } } }
public void TestParser() { string filePath = @"TestData\BAM\SeqAlignment.bam"; BAMParser parser = new BAMParser(); SequenceAlignmentMap alignmentMap = parser.Parse(filePath); Assert.IsTrue(alignmentMap != null); Assert.AreEqual(alignmentMap.Header.GetReferenceSequences().Count, 1); Assert.AreEqual(alignmentMap.QuerySequences.Count, 2); }
public void TestOrphanRegionssUsingSAMFile() { string samFilename = @"TestUtils\SAM\PairedReadsTest.sam"; using (SAMParser bamParser = new SAMParser()) { SequenceAlignmentMap alignmentMapobj = bamParser.Parse(samFilename); TestOrphanRegions(alignmentMapobj); } }
public void TestOrphansRegionsUsingBAMFile() { string bamFilename = @"TestUtils\BAM\PairedReadsTest.bam"; using (BAMParser bamParser = new BAMParser()) { SequenceAlignmentMap alignmentMapobj = bamParser.Parse(bamFilename); TestOrphanRegions(alignmentMapobj); } }
public void TestLengthAnomaliesUsingBAMfile() { string bamFilename = @"TestUtils\BAM\PairedReadsTest.bam"; using (BAMParser bamParser = new BAMParser()) { SequenceAlignmentMap alignmentMapobj = bamParser.Parse(bamFilename); TestLengthAnomalies(alignmentMapobj); } }
public void TestChimeraDataUsingSAMfile() { string samFilename = @"TestUtils\SAM\PairedReadsTest.sam"; using (SAMParser bamParser = new SAMParser()) { SequenceAlignmentMap alignmentMapobj = bamParser.Parse(samFilename); TestChimeraData(alignmentMapobj); } }
public void ValidateSAMParserWithEmptyAlignmentMap() { SAMParser parser = new SAMParser(); SequenceAlignmentMap alignment = parser.Parse(Utility._xmlUtil.GetTextValue( Constants.EmptySamFileNode, Constants.FilePathNode)); Assert.AreEqual(null, alignment); }
public void TestALLtypePairedReadsInSAMFile() { string samfilePath = @"TestUtils\SAM\PairedReadsTest.sam"; using (SAMParser parser = new SAMParser()) { SequenceAlignmentMap map = parser.Parse(samfilePath); int TotalReadsCount = 77; int unpairedReadsCount = 2; int multipleHitsPairCount = 2; int multipleHitReadsCount = 8; int normalPairCount = 4; int normalreadsCount = 2 * normalPairCount; int orphanPairsCount = 3; int orphanreadsCount = 5; int chimerapaircount = 15; int chimerareadsCount = 2 * chimerapaircount; int strucAnomPairCount = 3; int strucAnomReadsCount = 2 * strucAnomPairCount; int lenAnomPairCount = 9; int LenAnomReadsCount = 2 * lenAnomPairCount; int total = unpairedReadsCount + multipleHitReadsCount + normalreadsCount + orphanreadsCount + chimerareadsCount + strucAnomReadsCount + LenAnomReadsCount; Assert.AreEqual(TotalReadsCount, total); IList <PairedRead> reads = map.GetPairedReads(200, 50); IList <PairedRead> multipleHits = reads.Where(PE => PE.PairedType == PairedReadType.MultipleHits).ToList(); IList <PairedRead> normal = reads.Where(PE => PE.PairedType == PairedReadType.Normal).ToList(); IList <PairedRead> orphan = reads.Where(PE => PE.PairedType == PairedReadType.Orphan).ToList(); IList <PairedRead> chimera = reads.Where(PE => PE.PairedType == PairedReadType.Chimera).ToList(); IList <PairedRead> strucAnom = reads.Where(PE => PE.PairedType == PairedReadType.StructuralAnomaly).ToList(); IList <PairedRead> lenAnom = reads.Where(PE => PE.PairedType == PairedReadType.LengthAnomaly).ToList(); Assert.AreEqual(TotalReadsCount, map.QuerySequences.Count); Assert.AreEqual(multipleHitsPairCount, multipleHits.Count()); Assert.AreEqual(multipleHitReadsCount, multipleHits.Sum(PE => PE.Reads.Count)); Assert.AreEqual(normalPairCount, normal.Count()); Assert.AreEqual(normalreadsCount, normal.Sum(PE => PE.Reads.Count)); Assert.AreEqual(orphanPairsCount, orphan.Count()); Assert.AreEqual(orphanreadsCount, orphan.Sum(PE => PE.Reads.Count)); Assert.AreEqual(chimerapaircount, chimera.Count()); Assert.AreEqual(chimerareadsCount, chimera.Sum(PE => PE.Reads.Count)); Assert.AreEqual(strucAnomPairCount, strucAnom.Count()); Assert.AreEqual(strucAnomReadsCount, strucAnom.Sum(PE => PE.Reads.Count)); Assert.AreEqual(lenAnomPairCount, lenAnom.Count()); Assert.AreEqual(LenAnomReadsCount, lenAnom.Sum(PE => PE.Reads.Count)); } }
public void TestFormatter() { string filePath = @"TestUtils\BAM\SeqAlignment.bam"; string outputfilePath = "BAMTests123.bam"; BAMParser parser = null; try { parser = new BAMParser(); BAMFormatter formatter = new BAMFormatter(); SequenceAlignmentMap alignmentMap = parser.Parse(filePath); 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.Format(alignmentMap, outputfilePath); formatter.CreateSortedBAMFile = true; formatter.CreateIndexFile = true; alignmentMap = parser.Parse(filePath); formatter.Format(alignmentMap, outputfilePath); Assert.IsTrue(File.Exists("BAMTests123.bam.bai")); alignmentMap = parser.Parse(outputfilePath); Assert.IsTrue(alignmentMap != null); 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.IsTrue(alignmentMap != null); 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.IsTrue(alignmentMap != null); Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1); Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1); Assert.AreEqual(alignmentMap.QuerySequences.Count, 1); } finally { if (parser != null) { parser.Dispose(); } } }
// Validates the alignment. private SequenceAlignmentMap ValidateAlignment(ISequenceAlignment sequenceAlignment) { SequenceAlignmentMap seqAlignmentMap = sequenceAlignment as SequenceAlignmentMap; if (seqAlignmentMap != null) { ValidateAlignmentHeader(seqAlignmentMap.Header); if (CreateSortedBAMFile && SortType == BAMSortByFields.ChromosomeNameAndCoordinates) { this.refSequences = SortSequenceRanges(seqAlignmentMap.Header.GetReferenceSequenceRanges()); } else { this.refSequences = seqAlignmentMap.Header.GetReferenceSequenceRanges(); } return(seqAlignmentMap); } SAMAlignmentHeader header = sequenceAlignment.Metadata[Helper.SAMAlignmentHeaderKey] as SAMAlignmentHeader; if (header == null) { throw new ArgumentException(Properties.Resource.SAMAlignmentHeaderNotFound); } ValidateAlignmentHeader(header); seqAlignmentMap = new SequenceAlignmentMap(header); if (CreateSortedBAMFile && SortType == BAMSortByFields.ChromosomeNameAndCoordinates) { this.refSequences = SortSequenceRanges(seqAlignmentMap.Header.GetReferenceSequenceRanges()); } else { this.refSequences = seqAlignmentMap.Header.GetReferenceSequenceRanges(); } foreach (IAlignedSequence alignedSeq in sequenceAlignment.AlignedSequences) { SAMAlignedSequenceHeader alignedHeader = alignedSeq.Metadata[Helper.SAMAlignedSequenceHeaderKey] as SAMAlignedSequenceHeader; if (alignedHeader == null) { throw new ArgumentException(Properties.Resource.SAMAlignedSequenceHeaderNotFound); } SAMAlignedSequence samAlignedSeq = new SAMAlignedSequence(alignedHeader); samAlignedSeq.QuerySequence = alignedSeq.Sequences[0]; seqAlignmentMap.QuerySequences.Add(samAlignedSeq); } return(seqAlignmentMap); }
/// <summary> /// General method to validate SAM parser method. /// </summary> /// <param name="nodeName">xml node name</param> /// <param name="parseTypes">enum type to execute different overload</param> void ValidateSAMParserSeqAlign( string nodeName, ParseOrFormatTypes method) { // Gets the expected sequence from the Xml string filePath = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.FilePathNode); string expectedSequenceFile = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.ExpectedSequence); using (SAMParser parser = new SAMParser()) { SequenceAlignmentMap alignments = null; // Parse SAM File switch (method) { case ParseOrFormatTypes.ParseOrFormatText: using (TextReader reader = new StreamReader(filePath)) { alignments = parser.Parse(reader); } break; case ParseOrFormatTypes.ParseOrFormatFileName: alignments = parser.Parse(filePath); break; } // Get expected sequences using (FastAParser parserObj = new FastAParser(expectedSequenceFile)) { IEnumerable <ISequence> expectedSequences = parserObj.Parse(); IList <ISequence> expectedSequencesList = expectedSequences.ToList(); // Validate parsed output with expected output for (int index = 0; index < alignments.QuerySequences.Count; index++) { for (int count = 0; count < alignments.QuerySequences[index].Sequences.Count; count++) { Assert.AreEqual(new string(expectedSequencesList[index].Select(a => (char)a).ToArray()), new string(alignments.QuerySequences[index].Sequences[count].Select(a => (char)a).ToArray())); } } } } }
// Validates the alignment. private SequenceAlignmentMap ValidateAlignment(ISequenceAlignment sequenceAlignment) { SequenceAlignmentMap seqAlignmentMap = sequenceAlignment as SequenceAlignmentMap; if (seqAlignmentMap != null) { ValidateAlignmentHeader(seqAlignmentMap.Header); _refSequences = SortSequenceRanges(seqAlignmentMap.Header.GetReferenceSequenceRanges()); foreach (SAMAlignedSequence alignedSequence in seqAlignmentMap.QuerySequences) { string message = alignedSequence.IsValidHeader(); if (!string.IsNullOrEmpty(message)) { throw new ArgumentException(message); } ValidateSQHeader(alignedSequence.RName); } return(seqAlignmentMap); } SAMAlignmentHeader header = sequenceAlignment.Metadata[Helper.SAMAlignmentHeaderKey] as SAMAlignmentHeader; if (header == null) { throw new ArgumentException(Resource.SAMAlignmentHeaderNotFound); } ValidateAlignmentHeader(header); seqAlignmentMap = new SequenceAlignmentMap(header); _refSequences = SortSequenceRanges(seqAlignmentMap.Header.GetReferenceSequenceRanges()); foreach (IAlignedSequence alignedSeq in sequenceAlignment.AlignedSequences) { SAMAlignedSequenceHeader alignedHeader = alignedSeq.Metadata[Helper.SAMAlignedSequenceHeaderKey] as SAMAlignedSequenceHeader; if (alignedHeader == null) { throw new ArgumentException(Resource.SAMAlignedSequenceHeaderNotFound); } ValidateAlignedSequenceHeader(alignedHeader); ValidateSQHeader(alignedHeader.RName); SAMAlignedSequence samAlignedSeq = new SAMAlignedSequence(alignedHeader); samAlignedSeq.QuerySequence = alignedSeq.Sequences[0]; } return(seqAlignmentMap); }
/// <summary> /// General method to validate SAM Formatter method. /// </summary> /// <param name="nodeName">xml node name</param> /// <param name="parseTypes">enum type to execute different overload</param> void ValidateSAMFormatterSeqAlign( string nodeName, ParseOrFormatTypes parseTypes) { // Gets the expected sequence from the Xml string filePath = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.FilePathNode).TestDir(); string expectedSequenceFile = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.ExpectedSequence).TestDir(); SAMParser parser = new SAMParser(); { SequenceAlignmentMap alignments = parser.ParseOne <SequenceAlignmentMap>(filePath); SAMFormatter formatter = new SAMFormatter(); switch (parseTypes) { case ParseOrFormatTypes.ParseOrFormatText: using (var writer = File.Create(Constants.SAMTempFileName)) { formatter.Format(writer, alignments); } break; case ParseOrFormatTypes.ParseOrFormatFileName: formatter.Format(alignments, Constants.SAMTempFileName); break; } alignments = parser.ParseOne <SequenceAlignmentMap>(Constants.SAMTempFileName); // Get expected sequences FastAParser parserObj = new FastAParser(); { IEnumerable <ISequence> expectedSequences = parserObj.Parse(expectedSequenceFile); IList <ISequence> expectedSequencesList = expectedSequences.ToList(); // Validate parsed output with expected output for (int index = 0; index < alignments.QuerySequences.Count; index++) { for (int count = 0; count < alignments.QuerySequences[index].Sequences.Count; count++) { Assert.AreEqual(new string(expectedSequencesList[index].Select(a => (char)a).ToArray()), new string(alignments.QuerySequences[index].Sequences[count].Select(a => (char)a).ToArray())); } } } } }
/// <summary> /// Writes specified alignment object to a stream. /// The output is formatted according to the BAM specification. /// Note that this method does not create index file. /// </summary> /// <param name="sequenceAlignmentMap">SequenceAlignmentMap object.</param> /// <param name="writer">Stream to write BAM data.</param> public void Format(SequenceAlignmentMap sequenceAlignmentMap, Stream writer) { if (sequenceAlignmentMap == null) { throw new ArgumentNullException("sequenceAlignmentMap"); } if (writer == null) { throw new ArgumentNullException("writer"); } WriteSequenceAlignment(sequenceAlignmentMap, writer, null); }