public HaploGrepSharp.NewSearchMethods.HaploTypeReport OutputAssembly(string fileNamePrefix)
{
if (SuccessfulAssembly)
{
FastAFormatter fa = new FastAFormatter(fileNamePrefix + "BestGreedyAssembly.fna");
StringBuilder sb = new StringBuilder(StaticResources.CRS_LENGTH);
var bestAssembly = GreedyPathAssembly;
bestAssembly.FinalizeAndOrientToReference();
Bio.Sequence s = new Bio.Sequence(bestAssembly.Sequence);
s.ID = "GreedyAssembly - length=" + AssemblyLength.ToString(); // + bestAssembly.FirstReferencePosition.Value.ToString() + " - " + GreedyPathAssembly.LastReferencePosition.Value.ToString();
fa.Write(s);
fa.Close();
//Now report all differences as well
StreamWriter sw = new StreamWriter(fileNamePrefix + "Report.txt");
var searcher = new HaploGrepSharp.NewSearchMethods.HaplotypeSearcher();
List <string> linesToWrite = new List <string> ();
var report = searcher.GetHaplotypeReport(s, linesToWrite, fileNamePrefix);
foreach (var l in linesToWrite)
{
sw.WriteLine(l);
}
sw.Close();
return(report);
}
return(null);
}
/// <summary>
/// The execution method for the activity.
/// </summary>
/// <param name="executionContext">The execution context.</param>
/// <returns>The execution status.</returns>
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
FastAFormatter formatter = new FastAFormatter();
formatter.Open(OutputFile);
if ((Sequence == null) && (SequenceList != null))
{
foreach (ISequence sequence in SequenceList)
{
formatter.Write(sequence);
}
}
else if ((Sequence != null) && (SequenceList == null))
{
formatter.Write(Sequence);
}
else if ((Sequence != null) && (SequenceList != null))
{
foreach (ISequence sequence in SequenceList)
{
formatter.Write(sequence);
}
formatter.Write(Sequence);
}
formatter.Close();
return(ActivityExecutionStatus.Closed);
}
/// <summary>
/// Get the blast service request object with all the request parameter set
/// </summary>
/// <param name="sequence">Input sequece</param>
/// <param name="parameters">Blast parameters</param>
/// <returns>Blast service request object</returns>
private static BlastSerivceRequest GetRequestParameter(
ISequence sequence,
BlastParameters parameters)
{
BlastSerivceRequest blastParameter = new BlastSerivceRequest();
// Sets the format of output expected from Azure Blast service
blastParameter.OptionM = OPTIONMVALUE;
// Sets the name of Job owner
blastParameter.Owner = Resources.OWNERVALUE;
blastParameter.ParitionNumber = PARTITIONVALUE;
// Convert string to byte
string inputContent = FastAFormatter.FormatString(sequence);
ASCIIEncoding asciiEncoding = new ASCIIEncoding();
blastParameter.InputContent = asciiEncoding.GetBytes(inputContent);
// Other parameters
// Set the Title of Job
blastParameter.Title = sequence.ID;
// Name of the database to be searched in
blastParameter.DatabaseName = parameters.Settings[PARAMETERDATABASE];
// Type of search program to be executed
blastParameter.ProgramName = parameters.Settings[PARAMETERPROGRAM];
return(blastParameter);
}
/// <summary>
/// Writes the contigs to the file.
/// </summary>
/// <param name="assembly">IDeNovoAssembly parameter is the result of running De Novo Assembly on a set of two or more sequences. </param>
protected void writeContigs(PadenaAssembly assembly)
{
if (assembly.AssembledSequences.Count == 0)
{
Output.WriteLine(OutputLevel.Results, "\tNo sequences assembled.");
return;
}
ensureContigNames(assembly.AssembledSequences);
if (!string.IsNullOrEmpty(this.DiagnosticFilePrefix))
{
using (FastAFormatter formatter = new FastAFormatter(ContigFileName)) {
formatter.AutoFlush = true;
foreach (ISequence seq in assembly.AssembledSequences)
{
formatter.Write(seq);
}
}
Output.WriteLine(OutputLevel.Information, "\tWrote {0} sequences to {1}", assembly.AssembledSequences.Count, ContigFileName);
}
else
{
Output.WriteLine(OutputLevel.Information, "\tAssembled Sequence Results: {0} sequences", assembly.AssembledSequences.Count);
using (FastAFormatter formatter = new FastAFormatter()) {
formatter.Open(new StreamWriter(Console.OpenStandardOutput()));
formatter.MaxSymbolsAllowedPerLine = decideOutputWidth();
formatter.AutoFlush = true;
foreach (ISequence seq in assembly.AssembledSequences)
{
formatter.Write(seq);
}
}
}
}
/// <summary>
/// It writes Contigs to the file.
/// </summary>
/// <param name="scaffolds">The list of scaffolds sequence.</param>
private void WriteContigs(IList <ISequence> scaffolds)
{
if (scaffolds.Count == 0)
{
Output.WriteLine(OutputLevel.Information, "No Scaffolds generated.");
return;
}
EnsureContigNames(scaffolds);
if (!string.IsNullOrEmpty(this.OutputFile))
{
FastAFormatter formatter = new FastAFormatter {
AutoFlush = true
};
using (formatter.Open(this.OutputFile))
{
formatter.Format(scaffolds);
}
Output.WriteLine(OutputLevel.Information, "Wrote {0} scaffolds to {1}", scaffolds.Count, this.OutputFile);
}
else
{
Output.WriteLine(OutputLevel.Information, "Scaffold Results: {0} sequences", scaffolds.Count);
FastAFormatter formatter = new FastAFormatter {
MaxSymbolsAllowedPerLine = Math.Min(80, Console.WindowWidth - 2),
AutoFlush = true
};
formatter.Format(Console.OpenStandardOutput(), scaffolds);
}
}
public void FastAFormatterValidateWrite()
{
using (FastAFormatter formatter = new FastAFormatter(Constants.FastaTempFileName))
{
// Gets the actual sequence and the alphabet from the Xml
string actualSequence = utilityObj.xmlUtil.GetTextValue(Constants.SimpleFastaNodeName,
Constants.ExpectedSequenceNode);
string alpName = utilityObj.xmlUtil.GetTextValue(Constants.SimpleFastaNodeName,
Constants.AlphabetNameNode);
// Logs information to the log file
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"FastA Formatter BVT: Validating with Sequence '{0}' and Alphabet '{1}'.",
actualSequence, alpName));
Sequence seqOriginal = new Sequence(Utility.GetAlphabet(alpName),
actualSequence);
seqOriginal.ID = "";
Assert.IsNotNull(seqOriginal);
// Use the formatter to write the original sequences to a temp file
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"FastA Formatter BVT: Creating the Temp file '{0}'.", Constants.FastaTempFileName));
formatter.Write(seqOriginal);
formatter.Close();
IEnumerable <ISequence> seqsNew = null;
// Read the new file, then compare the sequences
using (FastAParser parser = new FastAParser(Constants.FastaTempFileName))
{
parser.Alphabet = Alphabets.Protein;
seqsNew = parser.Parse();
char[] seqString = seqsNew.ElementAt(0).Select(a => (char)a).ToArray();
string newSequence = new string(seqString);
Assert.IsNotNull(seqsNew);
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"FastA Formatter BVT: New Sequence is '{0}'.",
newSequence));
// Now compare the sequences.
int countNew = seqsNew.Count();
Assert.AreEqual(1, countNew);
ApplicationLog.WriteLine("The Number of sequences are matching.");
Assert.AreEqual(seqOriginal.ID, seqsNew.ElementAt(0).ID);
string orgSeq = new string(seqsNew.ElementAt(0).Select(a => (char)a).ToArray());
Assert.AreEqual(orgSeq, newSequence);
Console.WriteLine(string.Format((IFormatProvider)null,
"FastA Formatter BVT: The FASTA sequences '{0}' are matching with Format() method and is as expected.",
newSequence));
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"FastA Formatter BVT: The FASTA sequences '{0}' are matching with Format() method.",
newSequence));
}
// Passed all the tests, delete the tmp file. If we failed an Assert,
// the tmp file will still be there in case we need it for debugging.
File.Delete(Constants.FastaTempFileName);
ApplicationLog.WriteLine("Deleted the temp file created.");
}
}
public void FastAFormatterValidateGetDescription()
{
var formatter = new FastAFormatter();
string desc = formatter.Description;
Assert.IsNotNull(desc);
}
/// <summary>
/// Returns parser which supports the specified file.
/// </summary>
/// <param name="fileName">File name for which the parser is required.</param>
/// <param name="formatterName">Name of the formatter to use.</param>
/// <returns>If found returns the formatter as ISequenceFormatter else returns null.</returns>
public static ISequenceFormatter FindFormatterByName(string fileName, string formatterName)
{
ISequenceFormatter formatter = null;
if (!string.IsNullOrEmpty(fileName))
{
if (formatterName == Properties.Resource.FastAName)
{
formatter = new FastAFormatter(fileName);
}
else if (formatterName == Properties.Resource.FastQName)
{
formatter = new FastQFormatter(fileName);
}
else if (formatterName == Properties.Resource.GENBANK_NAME)
{
formatter = new GenBankFormatter(fileName);
}
else if (formatterName == Properties.Resource.GFF_NAME)
{
formatter = new GffFormatter(fileName);
}
else
{
formatter = null;
}
}
return(formatter);
}
public void ValidateSeqFormatterProperties()
{
// Gets the expected sequence from the Xml
string fastaFormatterName = this.utilityObj.xmlUtil.GetTextValue(Constants.FastAFileParserNode,
Constants.ParserNameNode);
string genBankFormatterName = this.utilityObj.xmlUtil.GetTextValue(Constants.GenBankFileParserNode,
Constants.ParserNameNode);
string gffFormatterName = this.utilityObj.xmlUtil.GetTextValue(Constants.GffFileParserNode,
Constants.ParserNameNode);
string fastQFormatterName = this.utilityObj.xmlUtil.GetTextValue(Constants.FastQFileParserNode,
Constants.ParserNameNode);
// Get SequenceFormatter class properties.
FastAFormatter actualFastAFormatter = SequenceFormatters.Fasta;
IReadOnlyList <ISequenceFormatter> allFormatters = SequenceFormatters.All;
GenBankFormatter actualgenBankFormatterName = SequenceFormatters.GenBank;
FastQFormatter actualFastQFormatterName = SequenceFormatters.FastQ;
GffFormatter actualGffFormatterName = SequenceFormatters.Gff;
// Validate Sequence Formatter
Assert.AreEqual(fastaFormatterName, actualFastAFormatter.Name);
Assert.AreEqual(genBankFormatterName, actualgenBankFormatterName.Name);
Assert.AreEqual(gffFormatterName, actualGffFormatterName.Name);
Assert.AreEqual(fastQFormatterName, actualFastQFormatterName.Name);
Assert.IsNotNull(allFormatters);
ApplicationLog.WriteLine("Type of the parser is validated successfully");
}
/// <summary>
/// Returns formatter which supports the specified file.
/// </summary>
/// <param name="fileName">File name for which the formatter is required.</param>
/// <returns>If found returns the formatter as ISequenceFormatter else returns null.</returns>
public static ISequenceFormatter FindFormatterByFileName(string fileName)
{
ISequenceFormatter formatter = null;
if (!string.IsNullOrEmpty(fileName))
{
if (IsFasta(fileName))
{
formatter = new FastAFormatter(fileName);
}
else if (IsFastQ(fileName))
{
formatter = new FastQFormatter(fileName);
}
else if (IsGenBank(fileName))
{
formatter = new GenBankFormatter(fileName);
}
else if (fileName.EndsWith(Properties.Resource.GFF_FILEEXTENSION, StringComparison.InvariantCultureIgnoreCase))
{
formatter = new GffFormatter(fileName);
}
else
{
formatter = null;
}
}
return(formatter);
}
/// <summary>
/// Writes the reads to StandardOutput.
/// </summary>
/// <param name="reads">Reads to write.</param>
private static void WriteOutput(IEnumerable <ISequence> reads)
{
foreach (ISequence seq in reads)
{
Console.WriteLine(FastAFormatter.FormatString(seq));
}
}
/// <summary>
/// Convert a list of ISequences to FASTA format and write to file. In order to reduce the amount of compute time required
/// by BLAST, we limit the number of sequences being fed to BLAST.
/// </summary>
/// <param name="sequences">IEnumerable list of Sequence objects</param>
/// <param name="output">Name of the output FASTA file</param>
/// <param name="maxSequences">Optional maximum number of sequences to convert</param>
/// <param name="overwrite">If true, any existing file with the same name will be overwritten. Otherwise, the file will not be overwritten and conversion will be skipped.</param>
/// <returns>True if a Fasta file was written, false if it already exists</returns>
public static bool ConvertToFASTA(IEnumerable <ISequence> sequences, string output, int maxSequences, bool overwrite = false)
{
// If conditions:
// 1. File doesn't exist; OR
// 2. File exists but is empty; OR
// 3. File exists but overwrite flag is set.
if (!File.Exists(output) || new FileInfo(output).Length == 0 || overwrite)
{
FastAFormatter fa = new FastAFormatter(output);
int count = 0;
foreach (var seqObj in sequences)
{
fa.Write(seqObj);
++count;
if (count >= maxSequences)
{
break;
}
}
fa.Close();
return(true);
}
return(false);
}
/// <summary>
/// Write sequences to the file
/// </summary>
/// <param name="sequences"></param>
private void WriteSequences(IEnumerable <ISequence> sequences)
{
if (!string.IsNullOrEmpty(this.OutputFile))
{
int count = 0;
using (var formatter = new FastAFormatter(this.OutputFile))
{
formatter.AutoFlush = true;
foreach (ISequence sequence in sequences)
{
count++;
formatter.Write(sequence);
}
}
Output.WriteLine(OutputLevel.Information, "Wrote {0} sequences to {1}.", count, this.OutputFile);
}
else
{
Output.WriteLine(OutputLevel.Information, "Results:");
foreach (ISequence seq in sequences)
{
Output.WriteLine(OutputLevel.Results, seq.ID);
Output.WriteLine(OutputLevel.Results, new string(seq.Select(a => (char)a).ToArray()));
}
}
}
/// <summary>
/// Returns parser which supports the specified file.
/// </summary>
/// <param name="fileName">File name for which the parser is required.</param>
/// <param name="formatterName">Name of the formatter to use.</param>
/// <returns>If found returns the formatter as ISequenceFormatter else returns null.</returns>
public static ISequenceFormatter FindFormatterByName(string fileName, string formatterName)
{
ISequenceFormatter formatter = null;
if (!string.IsNullOrEmpty(fileName))
{
if (formatterName == Properties.Resource.FastAName)
{
formatter = new FastAFormatter(fileName);
}
else if (formatterName == Properties.Resource.FastQName)
{
formatter = new FastQFormatter(fileName);
}
else if (formatterName == Properties.Resource.GENBANK_NAME)
{
formatter = new GenBankFormatter(fileName);
}
else
{
// Do a search through the known formatters to pick up custom formatters added through add-in.
formatter = All.FirstOrDefault(p => p.Name == formatterName);
// If we found a match based on extension, then open the file - this
// matches the above behavior where a specific formatter was created for
// the passed filename - the formatter is opened automatically in the constructor.
if (formatter != null)
{
formatter.Open(fileName);
}
}
}
return(formatter);
}
/// <summary>
/// Validates general FastA Parser test cases which are further Formatted
/// with the xml node name specified.
/// </summary>
/// <param name="nodeName">xml node name.</param>
private void ValidateParseFormatGeneralTestCases(string nodeName)
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode);
string alphabet = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.AlphabetNameNode);
Assert.IsTrue(File.Exists(filePath));
string filepathTmp = Path.Combine(Path.GetTempPath(), "temp.fasta");
// Ensure output is deleted
if (File.Exists(filepathTmp))
{
File.Delete(filepathTmp);
}
List <ISequence> seqsOriginal;
using (var parserObj = new FastAParser(filePath))
{
// Read the original file
parserObj.Alphabet = Utility.GetAlphabet(alphabet);
seqsOriginal = parserObj.Parse().ToList();
Assert.IsFalse(seqsOriginal.Count == 0);
}
// Write to a new file
using (var formatter = new FastAFormatter(filepathTmp))
{
formatter.Write(seqsOriginal);
}
try
{
// Compare original with new file
using (var parserObjNew = new FastAParser(filepathTmp))
{
// Read the new file, then compare the sequences
parserObjNew.Alphabet = Utility.GetAlphabet(alphabet);
IEnumerable <ISequence> seqsNew = parserObjNew.Parse();
Assert.IsNotNull(seqsNew);
int count = 0;
foreach (ISequence newSequence in seqsNew)
{
string s1 = seqsOriginal[count].ConvertToString();
string s2 = newSequence.ConvertToString();
Assert.AreEqual(s1, s2);
count++;
}
Assert.AreEqual(count, seqsOriginal.Count, "Number of sequences is different.");
}
}
finally
{
// Delete new file
File.Delete(filepathTmp);
}
}
/// <summary>
/// CreateJob() to get job id and control id and Submit job
/// using input sequence with job id and control id
/// </summary>
/// <param name="sequence">input sequences</param>
/// <param name="parameters">input params</param>
/// <returns>result params with job id and control id</returns>
public ServiceParameters SubmitRequest(IList <ISequence> sequence, ClustalWParameters parameters)
{
ServiceParameters result = new ServiceParameters();
if (null == sequence)
{
throw new ArgumentNullException("Sequence");
}
if (null == parameters)
{
throw new ArgumentNullException("Parameters");
}
// ClusterOption = biosim cbsum1 cbsum2k8 cbsusrv05 cbsum2 or Auto
string[] output = _baseClient.CreateJob(tAppId.P_CLUSTALW, "test_BioHPC_Job", "1", parameters.Values[ClustalWParameters.Email].ToString(),
string.Empty, parameters.Values[ClustalWParameters.ClusterOption].ToString());
if (!output[0].Contains(ERROR))
{
result.JobId = output[1];
result.Parameters.Add(CONTROLID, output[2]);
AppInputData inputData = _baseClient.InitializeApplicationParams(tAppId.P_CLUSTALW, "test_BioHPC_Job");
StringBuilder inputSequence = new StringBuilder();
foreach (ISequence seq in sequence)
{
inputSequence.AppendLine(FastAFormatter.FormatString(seq));
}
inputData.clustalw.inputsource = QuerySrcType.paste;
inputData.clustalw.inputstring = inputSequence.ToString();
inputData.clustalw.isDNA = false;
inputData.clustalw.action = (ClwActions)Enum.Parse(typeof(ClwActions),
parameters.Values[ClustalWParameters.ActionAlign].ToString());
inputData.clustalw.email_notify = true;
_baseClient.SubmitJob(result.JobId, result.Parameters[CONTROLID].ToString(), inputData);
result.Parameters.Add(SUBMISSONRESULT, SUCCESS);
// Only if the event is registered, invoke the thread
if (null != RequestCompleted)
{
// Start the BackGroundThread to check the status of job
_workerThread = new BackgroundWorker();
_workerThread.WorkerSupportsCancellation = true;
_workerThread.DoWork += new DoWorkEventHandler(ProcessRequestThread);
_workerThread.RunWorkerCompleted += new RunWorkerCompletedEventHandler(CompletedRequestThread);
_workerThread.RunWorkerAsync(result);
}
}
else
{
result.Parameters.Add(SUBMISSONRESULT, output[0]);
}
return(result);
}
/// <summary>
/// Exports a given list of sequences to a file in FastA format
/// </summary>
/// <param name="sequences">List of Sequences to be exported.</param>
/// <param name="filename">Target filename.</param>
static void ExportFastA(ICollection <ISequence> sequences, string filename)
{
// A formatter to export the output
FastAFormatter formatter = new FastAFormatter(filename);
// Exports the sequences to a file
formatter.Write(sequences);
}
/// <summary>
/// Exports a given sequence to a file in FastA format
/// </summary>
/// <param name="sequence">Sequence to be exported.</param>
/// <param name="filename">Target filename.</param>
static void ExportFastA(ISequence sequence, string filename)
{
// A formatter to export the output
FastAFormatter formatter = new FastAFormatter(filename);
// Exports the sequence to a file
formatter.Write(sequence);
}
public void FastAFormatterValidateGetName()
{
var formatter = new FastAFormatter();
string name = formatter.Name;
Assert.IsNotNull(name);
Assert.AreEqual(name, "FastA");
}
public void FastAFormatterValidateWriteWithStream()
{
string actualSequence = string.Empty;
using (var formatter = new FastAFormatter())
{
using (var writer = new StreamWriter(Constants.FastaTempFileName))
{
formatter.Open(writer);
// Gets the actual sequence and the alphabet from the Xml
actualSequence = utilityObj.xmlUtil.GetTextValue(Constants.SimpleFastaNodeName,
Constants.ExpectedSequenceNode);
string alpName = utilityObj.xmlUtil.GetTextValue(Constants.SimpleFastaNodeName,
Constants.AlphabetNameNode);
// Logs information to the log file
ApplicationLog.WriteLine(string.Format(null,
"FastA Formatter BVT: Validating with Sequence '{0}' and Alphabet '{1}'.",
actualSequence, alpName));
var seqOriginal = new Sequence(Utility.GetAlphabet(alpName),
actualSequence);
seqOriginal.ID = "";
Assert.IsNotNull(seqOriginal);
// Use the formatter to write the original sequences to a stream.
ApplicationLog.WriteLine(string.Format(null,
"FastA Formatter BVT: Creating the Temp file '{0}'.",
Constants.FastaTempFileName));
formatter.Write(seqOriginal);
formatter.Close();
}
IEnumerable <ISequence> seq = null;
using (var reader = new StreamReader(Constants.FastaTempFileName))
{
// Read the new file, then compare the sequences
using (var parser = new FastAParser())
{
parser.Alphabet = Alphabets.Protein;
seq = parser.Parse(reader);
//Create a list of sequences.
List <ISequence> seqsList = seq.ToList();
Assert.IsNotNull(seqsList);
var seqString = new string(seqsList[0].Select(a => (char)a).ToArray());
Assert.AreEqual(actualSequence, seqString);
}
}
// Passed all the tests, delete the tmp file. If we failed an Assert,
// the tmp file will still be there in case we need it for debugging.
File.Delete(Constants.FastaTempFileName);
ApplicationLog.WriteLine("Deleted the temp file created.");
}
}
public void FastAFormatterValidateGetName()
{
using (FastAFormatter formatter = new FastAFormatter())
{
string name = formatter.Name;
Assert.IsNotNull((object)name);
Assert.AreEqual(name, "FastA");
}
}
private void ValidateFormatterGeneralTestCases(string nodeName)
{
// Gets the actual sequence and the alphabet from the Xml
string expectedSequence = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.ExpectedSequenceNode);
string formattedSequence = expectedSequence.Replace("\r", "").Replace("\n", "").Replace(" ", "");
string alphabet = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.AlphabetNameNode);
// Logs information to the log file
ApplicationLog.WriteLine(string.Format(null,
"FastA Formatter : Validating with Sequence '{0}' and Alphabet '{1}'.",
expectedSequence, alphabet));
// Replacing all the empty characters, Paragraphs and null entries added
// while formatting the xml.
ISequence seqOriginal = new Sequence(Utility.GetAlphabet(alphabet), formattedSequence)
{
ID = "test"
};
Assert.IsNotNull(seqOriginal);
// Write it to a file
var formatter = new FastAFormatter();
{
// Use the formatter to write the original sequences to a temp file
ApplicationLog.WriteLine(string.Format("FastA Formatter : Creating the Temp file '{0}'.",
Constants.FastaTempFileName));
formatter.Format(seqOriginal, Constants.FastaTempFileName);
}
// Read the new file, then compare the sequences
var parserObj = new FastAParser();
{
parserObj.Alphabet = Utility.GetAlphabet(alphabet);
IEnumerable <ISequence> seqsNew = parserObj.Parse(Constants.FastaTempFileName);
// Get a single sequence
ISequence seqNew = seqsNew.FirstOrDefault();
Assert.IsNotNull(seqNew);
string newSequence = seqNew.ConvertToString();
ApplicationLog.WriteLine(string.Format(null, "FastA Formatter : New Sequence is '{0}'.", newSequence));
Assert.AreEqual(formattedSequence, newSequence);
Assert.AreEqual(seqOriginal.ID, seqNew.ID);
// Verify only one sequence exists.
Assert.AreEqual(1, seqsNew.Count());
}
// Passed all the tests, delete the tmp file. If we failed an Assert,
// the tmp file will still be there in case we need it for debugging.
File.Delete(Constants.FastaTempFileName);
ApplicationLog.WriteLine("Deleted the temp file created.");
}
private void WriteSequences(IEnumerable <ISequence> sequences)
{
using (FastAFormatter ff = new FastAFormatter(this.OutputFile))
{
foreach (ISequence sequence in sequences)
{
ff.Write(sequence);
}
}
}
/// <summary>
/// Writes delta for query sequences.
/// </summary>
/// <param name="delta">The Deltas.</param>
private void WriteDelta(
IList<List<IEnumerable<DeltaAlignment>>> delta)
{
TextWriter textWriterConsoleOutSave = Console.Out;
if (!string.IsNullOrEmpty(this.OutputFile))
{
FileStream fileStreamConsoleOut = new FileStream(this.OutputFile, FileMode.Create);
StreamWriter streamWriterConsoleOut = new StreamWriter(fileStreamConsoleOut);
Console.SetOut(streamWriterConsoleOut);
streamWriterConsoleOut.AutoFlush = true;
}
foreach (var alignment in delta)
{
foreach (IEnumerable<DeltaAlignment> align in alignment)
{
foreach (DeltaAlignment deltaAlignment in align)
{
Console.WriteLine(
">" +
deltaAlignment.ReferenceSequenceId);
if (deltaAlignment.QuerySequence != null)
{
Console.WriteLine(FastAFormatter.FormatString(deltaAlignment.QuerySequence).Substring(1));
}
else
{
//To provide empty lines in place of query sequence id and query sequence
Console.WriteLine();
Console.WriteLine();
}
Console.WriteLine(
deltaAlignment.FirstSequenceStart + " " +
deltaAlignment.FirstSequenceEnd + " " +
deltaAlignment.SecondSequenceStart + " " +
deltaAlignment.SecondSequenceEnd + " " +
deltaAlignment.Errors + " " +
deltaAlignment.SimilarityErrors + " " +
deltaAlignment.NonAlphas);
foreach (long deltas in deltaAlignment.Deltas)
{
Console.WriteLine(deltas);
}
Console.WriteLine("*");
}
Console.WriteLine("--");
}
}
Console.SetOut(textWriterConsoleOutSave);
}
public void FastAFormatterInvalidateClose()
{
try
{
FastAFormatter formatter = new FastAFormatter();
formatter.Close();
Assert.Fail();
}
catch (InvalidOperationException ex)
{
ApplicationLog.Write("Fasta P2 : InvalidOperationException caught successfully. " + ex.Message);
}
}
public void FastAFormatterInvalidateFormatString()
{
ISequence iSeq = null;
try
{
string formattedString = FastAFormatter.FormatString(iSeq);
Assert.Fail();
}
catch (ArgumentNullException ex)
{
ApplicationLog.Write("Fasta P2 : ArgumentNullException caught successfully. " + ex.Message);
}
}
public void FastAFormatterValidateGetSupportedFileTypes()
{
var formatter = new FastAFormatter();
string supportedFileType = formatter.SupportedFileTypes;
Assert.IsNotNull(supportedFileType);
Assert.IsTrue(supportedFileType.Contains(".fa"));
Assert.IsTrue(supportedFileType.Contains(".mpfa"));
Assert.IsTrue(supportedFileType.Contains(".fna"));
Assert.IsTrue(supportedFileType.Contains(".faa"));
Assert.IsTrue(supportedFileType.Contains(".fsa"));
Assert.IsTrue(supportedFileType.Contains(".fas"));
Assert.IsTrue(supportedFileType.Contains(".fasta"));
}
/// <summary>
/// Writes ambiguous reads that are filtered out to the specified file.
/// </summary>
/// <param name="ambiguousReads">Reads with ambiguous symbols.</param>
/// <param name="ambiguousFilename">File to write.</param>
private static void WriteAmbiguousReads(BlockingCollection <ISequence> ambiguousReads, string ambiguousFilename)
{
FastAFormatter formatter = new FastAFormatter(ambiguousFilename);
while (!ambiguousReads.IsCompleted)
{
ISequence seq;
if (ambiguousReads.TryTake(out seq, -1))
{
formatter.Write(seq);
formatter.Flush();
}
}
formatter.Close();
}
static void OldMain(string[] args)
{
StreamWriter SW = new StreamWriter(HOME + "CountsByDate.csv");
StreamReader SR = new StreamReader("FileLocations.csv");
string[] lines = SR.ReadToEnd().Split('\n');
lines = lines.Skip(1).ToArray();
// Parallel.ForEach(lines, line =>
Console.WriteLine("Starting");
foreach (string line in lines)
{
Console.WriteLine(line);
try
{
string[] split = line.Split(',');
string fname = split[0];
string patientid = split[1];
string date = split[2];
var mtReads = MitoDataGrabber.OutputMitoReadsFromBamFile(fname);
FastAFormatter fao = new FastAFormatter(HOME + patientid + ".fa");
long count = 0;
foreach (var seq in mtReads)
{
count++;
fao.Write(seq);
}
fao.Close();
FileInfo FI = new FileInfo(fname);
string size = FI.Length.ToString();
lock (SW)
{
SW.WriteLine(String.Join(",", patientid, count.ToString(), size, date));
Console.WriteLine(patientid + " has " + count.ToString() + " reads");
}
if (args.Length > 2)
{
break;
}
}
catch (Exception thrown)
{ Console.WriteLine(thrown.Message); }
}
//);
SW.Close();
}
public static async void AssemblySequences(string fastqFileName)
{
var parser = new FastQParser();
List <IQualitativeSequence> sequences = new List <IQualitativeSequence>();
using (var fileStream = new FileStream(fastqFileName, FileMode.Open))
{
sequences = parser.Parse(fileStream).ToList();
}
OverlapDeNovoAssembler assembler = new OverlapDeNovoAssembler();
IDeNovoAssembly assembly = assembler.Assemble(sequences);
FastAFormatter outputFormatter = new FastAFormatter();
outputFormatter.Open("assembled_sequences.fasta");
outputFormatter.Format(assembly.AssembledSequences);
outputFormatter.Close();
}
