/// <summary>
/// Validate the inputs.
/// </summary>
/// <param name="referenceSequence">Reference sequence.</param>
/// <param name="querySequenceList">List of input sequences.</param>
/// <returns>Are inputs valid.</returns>
private bool Validate(
ISequence referenceSequence,
IEnumerable <ISequence> querySequenceList)
{
bool isValidLength = false;
if (null == referenceSequence)
{
string message = Properties.Resource.ReferenceSequenceCannotBeNull;
Trace.Report(message);
throw new ArgumentNullException("referenceSequence");
}
if (null == querySequenceList)
{
string message = Properties.Resource.QueryListCannotBeNull;
Trace.Report(message);
throw new ArgumentNullException("querySequenceList");
}
if ((referenceSequence.Alphabet != Alphabets.DNA) && (referenceSequence.Alphabet != Alphabets.RNA))
{
string message = string.Format(
CultureInfo.CurrentCulture,
Properties.Resource.OnlyDNAOrRNAInput,
"MUMmer");
Trace.Report(message);
throw new ArgumentException(message, "referenceSequence");
}
// setting default similarity matrix based on DNA or RNA
if (SimilarityMatrix == null)
{
if (referenceSequence.Alphabet == Alphabets.RNA)
{
SimilarityMatrix = new SimilarityMatrix(SimilarityMatrix.StandardSimilarityMatrix.AmbiguousRna);
}
else if (referenceSequence.Alphabet == Alphabets.DNA)
{
SimilarityMatrix = new SimilarityMatrix(SimilarityMatrix.StandardSimilarityMatrix.AmbiguousDna);
}
}
if (!SimilarityMatrix.ValidateSequence(referenceSequence))
{
string message = Properties.Resource.FirstInputSequenceMismatchSimilarityMatrix;
Trace.Report(message);
throw new ArgumentException(message, "referenceSequence");
}
if (referenceSequence.Count < this.LengthOfMUM)
{
string message = String.Format(
CultureInfo.CurrentCulture,
Properties.Resource.InputSequenceMustBeGreaterThanMUM,
this.LengthOfMUM);
Trace.Report(message);
throw new ArgumentException(message, "referenceSequence");
}
foreach (ISequence querySequence in querySequenceList)
{
if (null == querySequence)
{
string message = Properties.Resource.QuerySequenceCannotBeNull;
Trace.Report(message);
throw new ArgumentNullException("querySequenceList", message);
}
if (referenceSequence.Alphabet != querySequence.Alphabet)
{
string message = Properties.Resource.InputAlphabetsMismatch;
Trace.Report(message);
throw new ArgumentException(message);
}
if (!SimilarityMatrix.ValidateSequence(querySequence))
{
string message = Properties.Resource.SecondInputSequenceMismatchSimilarityMatrix;
Trace.Report(message);
throw new ArgumentException(message, "querySequenceList");
}
if (querySequence.Count >= this.LengthOfMUM)
{
isValidLength = true;
}
}
if (!isValidLength)
{
string message = String.Format(
CultureInfo.CurrentCulture,
Properties.Resource.InputSequenceMustBeGreaterThanMUM,
this.LengthOfMUM);
Trace.Report(message);
throw new ArgumentException(message, "querySequenceList");
}
if (1 > this.LengthOfMUM)
{
string message = Properties.Resource.MUMLengthTooSmall;
Trace.Report(message);
throw new ArgumentException(message);
}
return(true);
}
/// <summary>
/// Method which performs the alignment work.
/// </summary>
/// <param name="sequence1">First sequence</param>
/// <param name="sequence2">Second sequence</param>
/// <param name="useAffineGapModel">True to use affine gap model (separate open vs. extension cost)</param>
/// <returns></returns>
private IList <IPairwiseSequenceAlignment> DoAlign(ISequence sequence1, ISequence sequence2, bool useAffineGapModel)
{
usingAffineGapModel = useAffineGapModel;
if (sequence1 == null)
{
throw new ArgumentNullException("sequence1");
}
if (sequence2 == null)
{
throw new ArgumentNullException("sequence2");
}
if (!Alphabets.CheckIsFromSameBase(sequence1.Alphabet, sequence2.Alphabet))
{
Trace.Report(Properties.Resource.InputAlphabetsMismatch);
throw new ArgumentException(Properties.Resource.InputAlphabetsMismatch);
}
if (SimilarityMatrix == null)
{
Trace.Report(Properties.Resource.SimilarityMatrixCannotBeNull);
throw new ArgumentException(Properties.Resource.SimilarityMatrixCannotBeNull);
}
if (!SimilarityMatrix.ValidateSequence(sequence1))
{
Trace.Report(Properties.Resource.FirstInputSequenceMismatchSimilarityMatrix);
throw new ArgumentException(Properties.Resource.FirstInputSequenceMismatchSimilarityMatrix);
}
if (!SimilarityMatrix.ValidateSequence(sequence2))
{
Trace.Report(Properties.Resource.SecondInputSequenceMismatchSimilarityMatrix);
throw new ArgumentException(Properties.Resource.SecondInputSequenceMismatchSimilarityMatrix);
}
if (GapOpenCost > GapExtensionCost)
{
Trace.Report(Properties.Resource.GapOpenGreaterThanGapExtension);
throw new ArgumentException(Properties.Resource.GapOpenGreaterThanGapExtension);
}
_sequence1 = sequence1;
_sequence2 = sequence2;
_gap = Alphabets.CheckIsFromSameBase(Alphabets.Protein, sequence1.Alphabet) ? Alphabets.Protein.Gap : Alphabets.DNA.Gap;
ReferenceSequence = GetByteArrayFromSequence(_sequence1);
QuerySequence = GetByteArrayFromSequence(_sequence2);
// Assign consensus resolver if it was not assigned already.
IAlphabet alphabet = sequence1.Alphabet;
if (ConsensusResolver == null)
{
ConsensusResolver = new SimpleConsensusResolver(alphabet.HasAmbiguity ? alphabet : Alphabets.AmbiguousAlphabetMap[sequence1.Alphabet]);
}
else
{
ConsensusResolver.SequenceAlphabet = alphabet.HasAmbiguity ? alphabet : Alphabets.AmbiguousAlphabetMap[sequence1.Alphabet];
}
return(new List <IPairwiseSequenceAlignment> {
Process()
});
}
