private bool Equals(Enzyme other)
{
return(base.Equals(other) &&
string.Equals(CleavageC, other.CleavageC) &&
string.Equals(RestrictC, other.RestrictC) &&
string.Equals(CleavageN, other.CleavageN) &&
string.Equals(RestrictN, other.RestrictN));
}
/*
public IEnumerable<PepV01> GetPeptides(SrmSettings settings, bool useFilter)
{
PeptideSettings pepSettings = settings.PeptideSettings;
Enzyme enzyme = pepSettings.Enzyme;
DigestSettings digest = pepSettings.DigestSettings;
IPeptideFilter filter = (useFilter ? pepSettings.Filter : PeptideFilter.UNFILTERED);
SequenceMassCalc massCalc = settings.GetPrecursorCalc(IsotopeLabelType.none);
RetentionTimeRegression rtRegression = pepSettings.Prediction.RetentionTime;
IEnumerable<PepV01> peptides = PeptideList ?
GetPeptideList(enzyme) : enzyme.Digest(this, digest, filter);
foreach (PepV01 peptide in peptides)
{
peptide.CalcMass(massCalc);
peptide.CalcRetentionTime(rtRegression);
yield return peptide;
}
}
*/
/// <summary>
/// Get the list of peptides from a <see cref="FastaSeqV01"/> where
/// <see cref="PeptideList"/> is true.
/// </summary>
/// <param name="enzyme">The enzyme used to detect missed cleavages in the peptides</param>
/// <returns>An enumerable list of <see cref="PepV01"/></returns>
public IEnumerable<PepV01> GetPeptideList(Enzyme enzyme)
{
if (!PeptideList)
throw new InvalidOperationException(Resources.FastaSeqV01_GetPeptideList_Attempt_to_get_peptide_list_from_uncleaved_FASTA_sequence);
int begin = 1;
int end = begin;
while (end < AA.Length - 1)
{
end = AA.IndexOf(PEPTIDE_SEPARATOR, begin);
string seqPep = AA.Substring(begin, end - begin);
int missedCleavages = enzyme.CountCleavagePoints(seqPep);
yield return new PepV01(this, begin, end, missedCleavages);
begin = end + 1;
}
}
private bool Equals(Enzyme other)
{
return base.Equals(other) &&
string.Equals(CleavageC, other.CleavageC) &&
string.Equals(RestrictC, other.RestrictC) &&
string.Equals(CleavageN, other.CleavageN) &&
string.Equals(RestrictN, other.RestrictN);
}
public PeptideSettings ChangeEnzyme(Enzyme prop)
{
return ChangeProp(ImClone(this), im => im.Enzyme = prop);
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
string name;
if (!helper.ValidateNameTextBox(textName, out name))
return;
string cleavageC;
if (!helper.ValidateAATextBox(textCleavage, false, out cleavageC))
return;
string restrictC;
if (!helper.ValidateAATextBox(textRestrict, true, out restrictC))
return;
string cleavageN;
string restrictN;
if (comboDirection.SelectedIndex == 2)
{
if (!helper.ValidateAATextBox(textCleavageN, false, out cleavageN))
return;
if (!helper.ValidateAATextBox(textRestrictN, true, out restrictN))
return;
}
else if (comboDirection.SelectedIndex == 1)
{
cleavageN = cleavageC;
cleavageC = null;
restrictN = restrictC;
restrictC = null;
}
else
{
cleavageN = null;
restrictN = null;
}
Enzyme enzyme = new Enzyme(name, cleavageC, restrictC, cleavageN, restrictN);
if (_enzyme == null && _existing.Contains(enzyme))
{
helper.ShowTextBoxError(textName, Resources.EditEnzymeDlg_OnClosing_The_enzyme__0__already_exists, name);
return;
}
_enzyme = enzyme;
DialogResult = DialogResult.OK;
}
public PeptideSettings(Enzyme enzyme,
DigestSettings digestSettings,
PeptidePrediction prediction,
PeptideFilter filter,
PeptideLibraries libraries,
PeptideModifications modifications,
PeptideIntegration integration,
BackgroundProteome backgroundProteome
)
{
Enzyme = enzyme;
DigestSettings = digestSettings;
Prediction = prediction;
Filter = filter;
Libraries = libraries;
Modifications = modifications;
Integration = integration;
BackgroundProteome = backgroundProteome;
Quantification = QuantificationSettings.DEFAULT;
}
public ProteaseImpl(Enzyme enzyme)
{
_enzyme = enzyme;
}
public Digestion Digest(Enzyme enzyme, DigestSettings digestSettings, ILoadMonitor loader)
{
ProgressStatus progressStatus = new ProgressStatus(string.Format(Resources.BackgroundProteomeSpec_Digest_Digesting__0__, enzyme.Name));
using (var proteomeDb = OpenProteomeDb())
{
return proteomeDb.Digest(new ProteaseImpl(enzyme),
(s, i) =>
{
loader.UpdateProgress(progressStatus.ChangePercentComplete(i));
return !loader.IsCanceled;
});
}
}
public PeptideGroupBuilder(FastaSequence fastaSequence, SrmSettings settings)
{
_activeFastaSeq = fastaSequence;
_autoManageChildren = true;
if (fastaSequence != null)
{
BaseName = Name = fastaSequence.Name;
Description = fastaSequence.Description;
Alternatives = fastaSequence.Alternatives.ToArray();
}
_settings = settings;
_enzyme = _settings.PeptideSettings.Enzyme;
_peptides = new List<PeptideDocNode>();
_charges = new Dictionary<int, int>();
_groupLibTriples = new List<TransitionGroupLibraryIrtTriple>();
_activeTransitionInfos = new List<ExTransitionInfo>();
_irtPeptides = new List<MeasuredRetentionTime>();
_librarySpectra = new List<SpectrumMzInfo>();
_activeLibraryIntensities = new List<SpectrumPeaksInfo.MI>();
_peptideGroupErrorInfo = new List<TransitionImportErrorInfo>();
_activeModifiedSequence = null;
}
private static void TestEditEnzymeDlg()
{
var enzymeList = Settings.Default.EnzymeList;
Enzyme enzymeExpect = new Enzyme("Trypsin Test", "KR", "P");
Enzyme enzyme = null;
RunDlg<EditEnzymeDlg>(() => { enzyme = enzymeList.EditItem(SkylineWindow, null, enzymeList, null); },
editEnzymeDlg =>
{
editEnzymeDlg.EnzymeName = enzymeExpect.Name;
editEnzymeDlg.Cleavage = enzymeExpect.CleavageC;
editEnzymeDlg.Restrict = enzymeExpect.RestrictC;
editEnzymeDlg.OkDialog();
});
Assert.AreEqual(enzymeExpect, enzyme);
RunDlg<EditEnzymeDlg>(() => { enzyme = enzymeList.EditItem(SkylineWindow, null, enzymeList, null); },
editEnzymeDlg =>
{
editEnzymeDlg.EnzymeName = enzymeExpect.Name;
editEnzymeDlg.Type = SequenceTerminus.N;
editEnzymeDlg.Cleavage = enzymeExpect.CleavageC;
editEnzymeDlg.Restrict = enzymeExpect.RestrictC;
editEnzymeDlg.OkDialog();
});
Assert.AreNotEqual(enzymeExpect, enzyme);
Assert.AreEqual(enzymeExpect.CleavageC, enzyme.CleavageN);
Assert.AreEqual(enzymeExpect.RestrictC, enzyme.RestrictN);
Assert.IsTrue(enzyme.IsNTerm);
Enzyme enzymeN = null;
RunDlg<EditEnzymeDlg>(() => { enzymeN = enzymeList.EditItem(SkylineWindow, enzyme, enzymeList, null); },
editEnzymeDlg =>
{
Assert.AreEqual(enzyme.Name, editEnzymeDlg.EnzymeName);
Assert.AreEqual(enzyme.CleavageN, editEnzymeDlg.Cleavage);
Assert.AreEqual(enzyme.RestrictN, editEnzymeDlg.Restrict);
Assert.AreEqual(SequenceTerminus.N, editEnzymeDlg.Type);
editEnzymeDlg.OkDialog();
});
Assert.AreEqual(enzyme, enzymeN);
RunDlg<EditEnzymeDlg>(() => { enzyme = enzymeList.EditItem(SkylineWindow, enzymeList.CopyItem(enzymeExpect), enzymeList, null); },
editEnzymeDlg =>
{
Assert.AreEqual(string.Empty, editEnzymeDlg.EnzymeName);
Assert.AreEqual(enzymeExpect.CleavageC, editEnzymeDlg.Cleavage);
Assert.AreEqual(enzymeExpect.RestrictC, editEnzymeDlg.Restrict);
Assert.AreEqual(SequenceTerminus.C, editEnzymeDlg.Type);
editEnzymeDlg.EnzymeName = enzymeExpect.Name;
editEnzymeDlg.OkDialog();
});
Assert.AreEqual(enzymeExpect, enzyme);
Enzyme enzymeBoth = new Enzyme("Bidirectional", "M", null, "K", null);
RunDlg<EditEnzymeDlg>(() => { enzyme = enzymeList.EditItem(SkylineWindow, null, enzymeList, null); },
editEnzymeDlg =>
{
editEnzymeDlg.EnzymeName = enzymeBoth.Name;
editEnzymeDlg.Type = null;
editEnzymeDlg.Cleavage = enzymeBoth.CleavageC;
editEnzymeDlg.CleavageN = enzymeBoth.CleavageN;
editEnzymeDlg.OkDialog();
});
Assert.AreEqual(enzymeBoth, enzyme);
RunDlg<EditEnzymeDlg>(() => { enzyme = enzymeList.EditItem(SkylineWindow, enzymeBoth, enzymeList, null); },
editEnzymeDlg =>
{
Assert.IsNull(editEnzymeDlg.Type);
Assert.AreEqual(enzymeBoth.CleavageC, editEnzymeDlg.Cleavage);
Assert.AreEqual(string.Empty, editEnzymeDlg.Restrict);
Assert.AreEqual(enzymeBoth.CleavageN, editEnzymeDlg.CleavageN);
Assert.AreEqual(string.Empty, editEnzymeDlg.RestrictN);
editEnzymeDlg.OkDialog();
});
Assert.AreEqual(enzymeBoth, enzyme);
// Test error messages
{
var editEnzymeDlg = ShowDialog<EditEnzymeDlg>(() => enzymeList.EditItem(SkylineWindow, null, enzymeList, null));
RunDlg<MessageDlg>(editEnzymeDlg.OkDialog, messageDlg =>
{
AssertEx.AreComparableStrings(Resources.MessageBoxHelper_ValidateNameTextBox__0__cannot_be_empty,
messageDlg.Message, 1);
messageDlg.OkDialog();
});
enzyme = enzymeList.First();
RunUI(() => editEnzymeDlg.EnzymeName = enzyme.Name);
RunDlg<MessageDlg>(editEnzymeDlg.OkDialog, messageDlg =>
{
AssertEx.AreComparableStrings(Resources.EditEnzymeDlg_ValidateAATextBox__0__must_contain_at_least_one_amino_acid,
messageDlg.Message, 1);
messageDlg.OkDialog();
});
const string badAA = "Z";
RunUI(() => editEnzymeDlg.Cleavage = enzyme.CleavageC + badAA);
RunDlg<MessageDlg>(editEnzymeDlg.OkDialog, messageDlg =>
{
Assert.AreEqual(string.Format(Resources.EditEnzymeDlg_ValidateAATextBox_The_character__0__is_not_a_valid_amino_acid, badAA),
messageDlg.Message);
messageDlg.OkDialog();
});
RunUI(() =>
{
editEnzymeDlg.Cleavage = enzyme.CleavageC;
editEnzymeDlg.Restrict = badAA;
});
RunDlg<MessageDlg>(editEnzymeDlg.OkDialog, messageDlg =>
{
Assert.AreEqual(string.Format(Resources.EditEnzymeDlg_ValidateAATextBox_The_character__0__is_not_a_valid_amino_acid, badAA),
messageDlg.Message);
messageDlg.OkDialog();
});
RunUI(() =>
{
editEnzymeDlg.Type = null;
editEnzymeDlg.Restrict = enzyme.RestrictC;
});
RunDlg<MessageDlg>(editEnzymeDlg.OkDialog, messageDlg =>
{
AssertEx.AreComparableStrings(Resources.EditEnzymeDlg_ValidateAATextBox__0__must_contain_at_least_one_amino_acid,
messageDlg.Message, 1);
messageDlg.OkDialog();
});
RunUI(() =>
{
editEnzymeDlg.CleavageN = enzyme.CleavageC;
editEnzymeDlg.RestrictN = badAA;
});
RunDlg<MessageDlg>(editEnzymeDlg.OkDialog, messageDlg =>
{
Assert.AreEqual(string.Format(Resources.EditEnzymeDlg_ValidateAATextBox_The_character__0__is_not_a_valid_amino_acid, badAA),
messageDlg.Message);
messageDlg.OkDialog();
});
RunUI(() => editEnzymeDlg.Type = SequenceTerminus.C);
RunDlg<MessageDlg>(editEnzymeDlg.OkDialog, messageDlg =>
{
AssertEx.AreComparableStrings(Resources.EditEnzymeDlg_OnClosing_The_enzyme__0__already_exists,
messageDlg.Message, 1);
messageDlg.AcceptButton.PerformClick();
});
RunUI(editEnzymeDlg.CancelButton.PerformClick);
WaitForClosedForm(editEnzymeDlg);
}
}
