public TransitionLoss(StaticMod precursorMod, FragmentLoss loss, MassType massType)
: this()
{
PrecursorMod = precursorMod;
Loss = loss;
Mass = Loss.GetMass(massType);
}
public void AddModification(StaticMod mod, ModType type)
{
if (mod == null)
{
return;
}
ImportPeptideSearch.UserDefinedTypedMods.Add(mod);
PeptideModifications peptideModifications = SkylineWindow.Document.Settings.PeptideSettings.Modifications;
if (type == ModType.structural)
{
peptideModifications = peptideModifications.ChangeStaticModifications(
peptideModifications.StaticModifications.Concat(new[] { mod }).ToArray());
}
else
{
peptideModifications = peptideModifications.AddHeavyModifications(new[] { mod });
}
SkylineWindow.ChangeSettings(SkylineWindow.Document.Settings.ChangePeptideSettings(
SkylineWindow.Document.Settings.PeptideSettings.ChangeModifications(peptideModifications)),
true,
string.Format(Resources.MatchModificationsControl_AddModification_Add__0__modification__1_, type, mod.Name));
SkylineWindow.Document.Settings.UpdateDefaultModifications(false);
FillLists(SkylineWindow.Document);
}
private bool HasAppropriateLinkedPeptide(StaticMod staticMod, int indexAA)
{
if (staticMod?.CrosslinkerSettings == null)
{
return(true);
}
LinkedPeptide linkedPeptide;
_linkedPeptides.TryGetValue(indexAA, out linkedPeptide);
if (linkedPeptide == null)
{
return(false);
}
if (!string.IsNullOrEmpty(staticMod.AAs))
{
string sequence = linkedPeptide.PeptideSequence ?? NodePeptide.Peptide.Sequence;
char aa = sequence[linkedPeptide.IndexAa];
if (!staticMod.AAs.Contains(aa))
{
return(false);
}
}
return(true);
}
public void Add(double mass, StaticMod mod, bool allowDuplicates)
{
var list = _listMasses;
switch (mod.Terminus)
{
case null:
if (string.IsNullOrEmpty(mod.AAs))
{
list = _listAllAAsMasses;
}
break;
case ModTerminus.C:
list = _listCTerminalMasses;
break;
case ModTerminus.N:
list = _listNTerminalMasses;
break;
}
if (allowDuplicates || !list.Contains(pair => pair.Key == mass))
{
list.Add(new KeyValuePair <double, StaticMod>(mass, mod));
}
}
public void AddModification(StaticMod mod, ModType type)
{
if (mod == null)
{
return;
}
ImportPeptideSearch.UserDefinedTypedMods.Add(mod);
PeptideModifications peptideModifications = DocumentContainer.Document.Settings.PeptideSettings.Modifications;
if (type == ModType.structural)
{
peptideModifications = peptideModifications.ChangeStaticModifications(
peptideModifications.StaticModifications.Concat(new[] { mod }).ToArray());
}
else
{
peptideModifications = peptideModifications.AddHeavyModifications(new[] { mod });
}
DocumentContainer.ModifyDocumentNoUndo(doc => doc.ChangeSettings(DocumentContainer.Document.Settings.ChangePeptideSettings(
DocumentContainer.Document.Settings.PeptideSettings.ChangeModifications(peptideModifications))));
DocumentContainer.Document.Settings.UpdateDefaultModifications(false);
FillLists(DocumentContainer.Document);
}
public void TestCrosslinkGetNeutralFormula()
{
var mainPeptide = new Peptide("MERCURY");
var srmSettings = SrmSettingsList.GetDefault();
srmSettings = srmSettings.ChangePeptideSettings(
srmSettings.PeptideSettings.ChangeModifications(srmSettings.PeptideSettings.Modifications
.ChangeStaticModifications(new StaticMod[0])));
var transitionGroup = new TransitionGroup(mainPeptide, Adduct.SINGLY_PROTONATED, IsotopeLabelType.light);
var mainTransitionGroupDocNode = new TransitionGroupDocNode(transitionGroup, Annotations.EMPTY, srmSettings,
null, null, ExplicitTransitionGroupValues.EMPTY, null, null, false);
var unlinkedFormula = mainTransitionGroupDocNode.GetNeutralFormula(srmSettings, null);
Assert.AreEqual("C37H61N13O11S2Se", unlinkedFormula.ToString());
var linkedPeptide = new LinkedPeptide(new Peptide("ARSENIC"), 2, null);
var linkedPeptideFormula = linkedPeptide.GetNeutralFormula(srmSettings, IsotopeLabelType.light);
Assert.AreEqual("C30H53N11O12S", linkedPeptideFormula.ToString());
var crosslinkMod = new StaticMod("disulfide", null, null, "-H2");
var explicitModsWithCrosslink = new ExplicitMods(mainPeptide,
new[] { new ExplicitMod(3, crosslinkMod).ChangeLinkedPeptide(linkedPeptide) },
new TypedExplicitModifications[0]);
var crosslinkedFormula =
mainTransitionGroupDocNode.GetNeutralFormula(srmSettings, explicitModsWithCrosslink);
Assert.AreEqual("C67H112N24O23S3Se", crosslinkedFormula.Molecule.ToString());
}
public void AddModification(StaticMod mod, IsotopeLabelType labelType)
{
if (MatcherPepMods.GetModificationTypes().Contains(labelType))
{
var newMods = MatcherPepMods.GetModifications(labelType)
.Where(existingMod => !existingMod.Equivalent(mod)).ToList();
newMods.Add(mod);
MatcherPepMods = MatcherPepMods.ChangeModifications(labelType, newMods);
}
else if (labelType.IsLight)
{
MatcherPepMods =
new PeptideModifications(new List <StaticMod> {
mod
}, MatcherPepMods.GetHeavyModifications().ToArray());
}
else
{
var typedHeavyMods =
new List <TypedModifications>(MatcherPepMods.GetHeavyModifications())
{
new TypedModifications(labelType, new List <StaticMod> {
mod
})
};
MatcherPepMods = new PeptideModifications(MatcherPepMods.StaticModifications, typedHeavyMods);
}
MatchesUpdated = true;
}
private static string GetMatchString(AAModKey key, StaticMod staticMod, bool structural)
{
string formatString = structural ? @"{0}[{1}{2}]" : @"{0}{{{1}{2}}}";
var modMass = Math.Round(GetDefaultModMass(key.AA, staticMod), key.RoundedTo);
return(string.Format(formatString, key.AA, (modMass > 0 ? @"+" : string.Empty), modMass));
}
public void TestGetIonFormula()
{
SequenceMassCalc sequenceMassCalc = new SequenceMassCalc(MassType.Monoisotopic);
Assert.AreEqual(147.11, sequenceMassCalc.GetPrecursorMass("K"), .1);
Assert.AreEqual("C6H14N2O2", sequenceMassCalc.GetMolecularFormula("K"));
var label13C6K = new StaticMod("label13C6K", "K", null, LabelAtoms.C13);
sequenceMassCalc.AddStaticModifications(new [] { label13C6K });
Assert.AreEqual(153.11, sequenceMassCalc.GetPrecursorMass("K"), .1);
Assert.AreEqual("C'6H14N2O2", sequenceMassCalc.GetMolecularFormula("K"));
var label15N2K = new StaticMod("label15N2K", "K", null, LabelAtoms.N15);
sequenceMassCalc.AddStaticModifications(new[] { label15N2K });
Assert.AreEqual(155.11, sequenceMassCalc.GetPrecursorMass("K"), .1);
Assert.AreEqual("C'6H14N'2O2", sequenceMassCalc.GetMolecularFormula("K"));
var labelLaK = new StaticMod("labelLaK", "K", null, "La");
sequenceMassCalc.AddStaticModifications(new[] { labelLaK });
Assert.AreEqual(294.033, sequenceMassCalc.GetPrecursorMass("K"), .1);
Assert.AreEqual("C'6H14LaN'2O2", sequenceMassCalc.GetMolecularFormula("K"));
// Check our ability to handle strangely constructed chemical formulas
Assert.AreEqual(Molecule.Parse("C12H9S2P0").ToString(), Molecule.Parse("C12H9S2").ToString()); // P0 is weird
Assert.AreEqual(Molecule.Parse("C12H9S2P1").ToString(), Molecule.Parse("C12H9S2P").ToString()); // P1 is weird
Assert.AreEqual(Molecule.Parse("C12H9S0P").ToString(), Molecule.Parse("C12H9P").ToString()); // S0 is weird, and not at end
}
private AAModMatch?GetModByName(AAModInfo info)
{
bool structural = false;
StaticMod modMatch = null;
// First, look in the document/global settings.
foreach (var mod in UserDefinedTypedMods.Keys)
{
bool matchStuctural = UserDefinedTypedMods[mod].IsLight;
if (Equals(info.Name, mod.Name) &&
(!info.UserIndicatedHeavy || !matchStuctural))
{
modMatch = mod;
structural = matchStuctural;
}
}
// If not found, then look in Unimod.
modMatch = modMatch ?? UniMod.GetModification(info.Name, out structural);
if (!info.IsModMatch(modMatch) || (info.UserIndicatedHeavy && structural))
{
return(null);
}
return(new AAModMatch
{
StructuralMod = structural ? modMatch : null,
HeavyMod = !structural ? modMatch : null
});
}
private StaticMod GetModByMassInSettings(AAModInfo info, double mass, bool structural)
{
StaticMod firstMatch = null;
foreach (var match in EnumerateModMatchesInSettings(info, mass, structural))
{
firstMatch = firstMatch ?? match;
// Keep looking if it is an isotope modification of the 15N variant where it applies to all amino acids
if (structural || (info.AppearsToBeSpecificMod && (!string.IsNullOrEmpty(match.AAs) || match.Terminus != null)) ||
(!info.AppearsToBeSpecificMod && string.IsNullOrEmpty(match.AAs) && match.Terminus == null))
{
firstMatch = match;
break;
}
}
if (firstMatch == null)
{
return(null);
}
// TODO: Is this necessary
if (!IsInSettings(firstMatch) && !firstMatch.IsVariable)
{
firstMatch = firstMatch.ChangeExplicit(true);
}
return(firstMatch);
}
public void AddModification(StaticMod mod, ModType type)
{
if (mod == null)
{
return;
}
ImportPeptideSearch.UserDefinedTypedMods.Add(mod);
PeptideSettings newPeptideSettings = SkylineWindow.Document.Settings.PeptideSettings;
var newMods = new List <StaticMod>(
(type == ModType.structural ? newPeptideSettings.Modifications.StaticModifications : newPeptideSettings.Modifications.HeavyModifications)
)
{
mod
};
newPeptideSettings = (type == ModType.structural)
? newPeptideSettings.ChangeModifications(newPeptideSettings.Modifications.ChangeStaticModifications(newMods))
: newPeptideSettings.ChangeModifications(newPeptideSettings.Modifications.ChangeHeavyModifications(newMods));
SkylineWindow.ChangeSettings(SkylineWindow.Document.Settings.ChangePeptideSettings(newPeptideSettings), true,
string.Format(Resources.MatchModificationsControl_AddModification_Add__0__modification__1_, type, mod.Name));
SkylineWindow.Document.Settings.UpdateDefaultModifications(false);
FillLists(SkylineWindow.Document);
}
public bool IsModMatch(StaticMod mod)
{
return(mod != null &&
(string.IsNullOrEmpty(mod.AAs) ||
mod.AminoAcids.ContainsAA(AA.ToString(CultureInfo.InvariantCulture))) &&
((mod.Terminus == null) || Equals(mod.Terminus, Terminus)));
}
/// <summary>
/// Returns the number of StaticMod values in the dictionary that are equivalent to modToMatch.
/// </summary>
/// <param name="dict">Dictionary containing StaticMod values.</param>
/// <param name="modToMatch">StaticMod we're comparing to values in dictionary.</param>
/// <param name="equivMods">Dictionary we add count for StaticMods equivalent to modToMatch.</param>
/// <param name="index">Index of modToMatch in dict.</param>
/// <returns>Number of StaticMods equivalent to modToMatch. If there are no equivalent values, function will return 1.</returns>
public int CountEquivalent(KeyValuePair <string, StaticMod>[] dict, StaticMod modToMatch, SortedDictionary <string, int> equivMods, int index)
{
int totalCount = 0;
for (int i = 0; i < dict.Length; i++)
{
int count = 0;
StaticMod mod = dict[i].Value;
if (index != -1 && index == i)
{
Assert.IsTrue(mod.Equivalent(modToMatch));
}
if (mod.Equivalent(modToMatch))
{
count++;
}
if (!equivMods.ContainsKey(mod.Name))
{
equivMods.Add(mod.Name, count);
}
else
{
equivMods[mod.Name] += count;
}
totalCount += count;
}
return(totalCount);
}
public List <int> PotentiallyModifiedResidues(PeptideDocNode peptideDocNode, StaticMod mod)
{
List <int> indexes = new List <int>();
var sequence = peptideDocNode.Peptide.Sequence;
for (int index = 0; index < sequence.Length; index++)
{
if (mod.Terminus == ModTerminus.N && index != 0)
{
continue;
}
if (mod.Terminus == ModTerminus.C && index != sequence.Length - 1)
{
continue;
}
if (mod.AAs != null)
{
var aa = sequence[index];
if (mod.AAs.IndexOf(aa) < 0)
{
continue;
}
}
indexes.Add(index);
}
return(indexes);
}
/// <summary>
/// Merge the modifications found by the matcher with the modifications in the document,
/// checking for conflicts with peptides already in the document.
/// </summary>
public PeptideModifications SafeMergeImplicitMods(SrmDocument document)
{
var newMods = MatcherPepMods;
var docModifications = document.Settings.PeptideSettings.Modifications;
var docPeptides = document.Molecules.ToArray();
List <StaticMod> lightMods = new List <StaticMod>(docModifications.StaticModifications);
List <StaticMod> heavyMods = new List <StaticMod>(docModifications.HeavyModifications);
// Merge light mods.
foreach (var mod in newMods.StaticModifications)
{
StaticMod mod1 = mod;
if (!lightMods.Contains(docMod => docMod.Equivalent(mod1)) &&
(!docPeptides.Any() || !ModAppliesToDoc(mod, true, true, docPeptides)))
{
lightMods.Add(mod1);
}
}
// Merge heavy mods.
foreach (var mod in newMods.GetModifications(DocDefHeavyLabelType))
{
var mod1 = mod;
if (!heavyMods.Contains(docMod => docMod.Equivalent(mod1)) &&
(!docPeptides.Any() || !ModAppliesToDoc(mod, false, true, docPeptides)))
{
heavyMods.Add(mod1);
}
}
return(document.Settings.PeptideSettings.Modifications.ChangeStaticModifications(lightMods).
ChangeModifications(DocDefHeavyLabelType, heavyMods));
}
public void TestSingleAminoAcidLinkedPeptide()
{
var srmSettings = SrmSettingsList.GetDefault();
var mainPeptide = new Peptide("A");
var staticMod = new StaticMod("crosslinker", null, null, "-C2");
var linkedPeptide = new LinkedPeptide(new Peptide("D"), 0, null);
var mainTransitionGroup = new TransitionGroup(mainPeptide, Adduct.SINGLY_PROTONATED, IsotopeLabelType.light);
var mainTransitionGroupDocNode = new TransitionGroupDocNode(mainTransitionGroup,
Annotations.EMPTY, srmSettings, null, null,
ExplicitTransitionGroupValues.EMPTY, null, new TransitionDocNode[0], false);
var modsWithoutLinkedPeptide = new ExplicitMods(mainPeptide, new[] { new ExplicitMod(0, staticMod), }, new TypedExplicitModifications[0]);
Assert.AreEqual("C3H7NO2", AminoAcidFormulas.Default.GetFormula("A").ToString());
Assert.AreEqual("C3H7NO2", mainTransitionGroupDocNode.GetNeutralFormula(srmSettings, null).Molecule.ToString());
Assert.AreEqual("CH7NO2", mainTransitionGroupDocNode.GetNeutralFormula(srmSettings, modsWithoutLinkedPeptide).Molecule.ToString());
Assert.AreEqual("C4H7NO4", AminoAcidFormulas.Default.GetFormula("D").ToString());
var modsWithLinkedPeptide = new ExplicitMods(mainPeptide,
new[] { new ExplicitMod(0, staticMod).ChangeLinkedPeptide(linkedPeptide) },
new TypedExplicitModifications[0]);
Assert.AreEqual("C5H14N2O6", mainTransitionGroupDocNode.GetNeutralFormula(srmSettings, modsWithLinkedPeptide).Molecule.ToString());
var mainComplexFragmentIon = new ComplexFragmentIon(new Transition(mainTransitionGroup, IonType.precursor, mainPeptide.Length - 1, 0, Adduct.SINGLY_PROTONATED), null, modsWithLinkedPeptide.Crosslinks);
var linkedComplexFragmentIon = new ComplexFragmentIon(
new Transition(linkedPeptide.GetTransitionGroup(IsotopeLabelType.light, Adduct.SINGLY_PROTONATED),
IonType.precursor, linkedPeptide.Peptide.Length - 1, 0, Adduct.SINGLY_PROTONATED), null, LinkedPeptide.EMPTY_CROSSLINK_STRUCTURE);
var complexFragmentIon =
mainComplexFragmentIon.AddChild(new ModificationSite(0, staticMod.Name), linkedComplexFragmentIon);
var transition = complexFragmentIon.MakeTransitionDocNode(srmSettings, modsWithLinkedPeptide, null);
var sequenceMassCalc = new SequenceMassCalc(MassType.Monoisotopic);
var expectedMz = sequenceMassCalc.GetPrecursorMass("A") + sequenceMassCalc.GetPrecursorMass("D") - 24 - BioMassCalc.MassProton;
Assert.AreEqual(expectedMz, transition.Mz, .00001);
}
public void TestComplexIonMz()
{
var srmSettings = SrmSettingsList.GetDefault();
var peptide = new Peptide("DLGEEHFKGLVLIAFSQYLQQCPFDEHVK");
var linkedPeptide = new LinkedPeptide(new Peptide("LVNELTEFAKTCVADESHAGCEK"), 9, null);
var transitionGroup = new TransitionGroup(peptide, Adduct.QUADRUPLY_PROTONATED, IsotopeLabelType.light);
var crosslinkMod = new StaticMod("linker", "K", null, "C8H10O2");
var explicitMod = new ExplicitMod(7, crosslinkMod).ChangeLinkedPeptide(linkedPeptide);
var explicitMods = new ExplicitMods(peptide, new[] { explicitMod }, new List <TypedExplicitModifications>());
var linkedTransition =
new Transition(linkedPeptide.GetTransitionGroup(IsotopeLabelType.light, Adduct.SINGLY_PROTONATED),
IonType.precursor, linkedPeptide.Peptide.Length - 1, 0, Adduct.SINGLY_PROTONATED);
var expectedMzs = new[]
{
Tuple.Create(IonType.b, 2, 1, 229.1183),
Tuple.Create(IonType.b, 10, 3, 1291.2766)
};
foreach (var tuple in expectedMzs)
{
int offset = Transition.OrdinalToOffset(tuple.Item1, tuple.Item2, peptide.Sequence.Length);
var transition = new Transition(transitionGroup, tuple.Item1, offset, 0, Adduct.FromChargeProtonated(tuple.Item3));
var complexFragmentIon = new ComplexFragmentIon(transition, null, explicitMods.Crosslinks);
if (complexFragmentIon.IncludesAaIndex(explicitMod.IndexAA))
{
complexFragmentIon = complexFragmentIon.AddChild(explicitMod.ModificationSite,
new ComplexFragmentIon(linkedTransition, null, LinkedPeptide.EMPTY_CROSSLINK_STRUCTURE));
}
var complexTransitionDocNode = complexFragmentIon.MakeTransitionDocNode(srmSettings, explicitMods, null);
Assert.AreEqual(tuple.Item4, complexTransitionDocNode.Mz, .0001, "{0}{1}{2}", tuple.Item1, tuple.Item2,
Transition.GetChargeIndicator(Adduct.FromChargeProtonated(tuple.Item3)));
}
}
public void TestCrosslinkModSerialization()
{
var settings = SrmSettingsList.GetDefault();
var crosslinkerDef = new StaticMod("disulfide", null, null, "-H2")
.ChangeCrosslinkerSettings(CrosslinkerSettings.EMPTY);
settings = settings.ChangePeptideSettings(settings.PeptideSettings.ChangeModifications(
settings.PeptideSettings.Modifications.ChangeStaticModifications(new[] { crosslinkerDef })));
settings = settings.ChangeTransitionSettings(settings.TransitionSettings.ChangeFilter(
settings.TransitionSettings.Filter
.ChangeFragmentRangeFirstName(TransitionFilter.StartFragmentFinder.ION_1.Name)
.ChangeFragmentRangeLastName(@"last ion")
.ChangePeptideIonTypes(new[] { IonType.precursor, IonType.y, IonType.b })
)); var mainPeptide = new Peptide("MERCURY");
var transitionGroup = new TransitionGroup(mainPeptide, Adduct.DOUBLY_PROTONATED, IsotopeLabelType.light);
var linkedPeptide = new LinkedPeptide(new Peptide("ARSENIC"), 2, null);
var crosslinkMod = new ExplicitMod(3, crosslinkerDef).ChangeLinkedPeptide(linkedPeptide);
var explicitModsWithCrosslink = new ExplicitMods(mainPeptide, new[] { crosslinkMod }, new TypedExplicitModifications[0]);
var transitionGroupDocNode = new TransitionGroupDocNode(transitionGroup, Annotations.EMPTY, settings,
explicitModsWithCrosslink, null, ExplicitTransitionGroupValues.EMPTY, null, null, true);
var peptideDocNode = new PeptideDocNode(mainPeptide, settings, explicitModsWithCrosslink, null, ExplicitRetentionTimeInfo.EMPTY, new [] { transitionGroupDocNode }, false);
peptideDocNode = peptideDocNode.ChangeSettings(settings, SrmSettingsDiff.ALL);
Assert.AreNotEqual(0, peptideDocNode.TransitionCount);
var peptideGroupDocNode = new PeptideGroupDocNode(new PeptideGroup(), Annotations.EMPTY, "Peptides", null, new [] { peptideDocNode });
var srmDocument = (SrmDocument) new SrmDocument(settings).ChangeChildren(new[] { peptideGroupDocNode });
AssertEx.Serializable(srmDocument);
string docXML = null;
AssertEx.RoundTrip(srmDocument, ref docXML);
Assert.IsNotNull(docXML);
}
public void TestPermuteComplexIons()
{
var mainPeptide = new Peptide("MERCURY");
var srmSettings = SrmSettingsList.GetDefault();
var transitionFilter = srmSettings.TransitionSettings.Filter;
transitionFilter = transitionFilter
.ChangeFragmentRangeFirstName(TransitionFilter.StartFragmentFinder.ION_1.Name)
.ChangeFragmentRangeLastName(@"last ion")
.ChangePeptideIonTypes(new[] { IonType.precursor, IonType.y, IonType.b });
srmSettings = srmSettings.ChangeTransitionSettings(
srmSettings.TransitionSettings.ChangeFilter(transitionFilter));
var transitionGroup = new TransitionGroup(mainPeptide, Adduct.SINGLY_PROTONATED, IsotopeLabelType.light);
var crosslinkerDef = new StaticMod("disulfide", "C", null, "-H2");
var linkedPeptide = new LinkedPeptide(new Peptide("ARSENIC"), 6, null);
var crosslinkMod = new ExplicitMod(3, crosslinkerDef).ChangeLinkedPeptide(linkedPeptide);
var explicitModsWithCrosslink = new ExplicitMods(mainPeptide, new[] { crosslinkMod }, new TypedExplicitModifications[0]);
var transitionGroupDocNode = new TransitionGroupDocNode(transitionGroup, Annotations.EMPTY, srmSettings,
explicitModsWithCrosslink, null, ExplicitTransitionGroupValues.EMPTY, null, null, false);
var choices = transitionGroupDocNode.GetPrecursorChoices(srmSettings, explicitModsWithCrosslink, true)
.Cast <TransitionDocNode>().ToArray();
var complexFragmentIons = choices.Select(transition => transition.ComplexFragmentIon.GetName()).ToArray();
Assert.AreNotEqual(0, complexFragmentIons.Length);
}
public void TestComplexIonGetNeutralFormula()
{
var srmSettings = SrmSettingsList.GetDefault();
var fullTransitionGroup = new TransitionGroupDocNode(
new TransitionGroup(new Peptide("ELVIS"), Adduct.SINGLY_PROTONATED, IsotopeLabelType.light),
Annotations.EMPTY, srmSettings, null, null, ExplicitTransitionGroupValues.EMPTY,
null, null, false);
var fullFormula = fullTransitionGroup.GetNeutralFormula(srmSettings, null);
Assert.AreEqual("C25H45N5O9", fullFormula.Molecule.ToString());
var hydrolysisDef = new StaticMod("hydrolysis", null, ModTerminus.C, "-H2O")
.ChangeCrosslinkerSettings(CrosslinkerSettings.EMPTY);
var crossLinkMod = new ExplicitMod(1, hydrolysisDef)
.ChangeLinkedPeptide(new LinkedPeptide(new Peptide("VIS"), 0, null));
var mainPeptide = new Peptide("EL");
var explicitMods = new ExplicitMods(mainPeptide, new[] { crossLinkMod }, new TypedExplicitModifications[0]);
var mainTransitionGroup = new TransitionGroupDocNode(
new TransitionGroup(mainPeptide, Adduct.SINGLY_PROTONATED, IsotopeLabelType.light),
Annotations.EMPTY, srmSettings,
explicitMods, null,
ExplicitTransitionGroupValues.EMPTY,
null, null, false);
var mainFullFormula = mainTransitionGroup.GetNeutralFormula(srmSettings, explicitMods);
Assert.AreEqual(fullFormula, mainFullFormula);
}
public void NeutralLossListTest()
{
TestSmallMolecules = false; // No concept of neutral loss for small molecules
var phosphoLossMod = new StaticMod("Phospho Loss", "S, T, Y", null, false, "HPO3",
LabelAtoms.None, RelativeRT.Matching, null, null, new[] { new FragmentLoss("H3PO4"), });
SrmDocument document = new SrmDocument(SrmSettingsList.GetDefault().ChangePeptideModifications(mods =>
mods.ChangeStaticModifications(new List <StaticMod>(mods.StaticModifications)
{
phosphoLossMod
})));
IdentityPath path = IdentityPath.ROOT;
SrmDocument docFasta = document.ImportFasta(new StringReader(TEXT_FASTA_YEAST_7), false, path, out path);
Assert.AreEqual(0, GetLossCount(docFasta, 1));
// Insert losses into the first transition group
var pathPeptide = docFasta.GetPathTo((int)SrmDocument.Level.Molecules, 0);
var nodePep = (PeptideDocNode)docFasta.FindNode(pathPeptide);
var nodeGroup = (TransitionGroupDocNode)nodePep.Children[0];
var listChildren = new List <DocNode>(nodeGroup.Children);
foreach (var nodeTran in nodeGroup.GetTransitions(docFasta.Settings,
nodePep.ExplicitMods, nodeGroup.PrecursorMz, null, null, null, false))
{
if (!nodeTran.HasLoss)
{
continue;
}
var tran = nodeTran.Transition;
int matchIndex = listChildren.IndexOf(node =>
Equals(tran, ((TransitionDocNode)node).Transition));
if (matchIndex == -1)
{
continue;
}
while (matchIndex < listChildren.Count &&
Equals(tran, ((TransitionDocNode)listChildren[matchIndex]).Transition))
{
matchIndex++;
}
listChildren.Insert(matchIndex, nodeTran);
}
var docLosses = (SrmDocument)docFasta.ReplaceChild(pathPeptide,
nodeGroup.ChangeChildren(listChildren));
int lossCount = GetLossCount(docLosses, 1);
Assert.IsTrue(lossCount > 0);
var docRoundTripped = AssertEx.RoundTripTransitionList(new ThermoMassListExporter(docLosses));
Assert.AreEqual(lossCount, GetLossCount(docRoundTripped, 1));
docRoundTripped = AssertEx.RoundTripTransitionList(new AgilentMassListExporter(docLosses));
Assert.AreEqual(lossCount, GetLossCount(docRoundTripped, 1));
}
/// <summary>
/// Create PeptideModifications matching the modifications indicated in the library.
/// </summary>
/// <param name="settings">The settings for the document for which the matches will be made</param>
public PeptideModifications CreateMatcherPeptideSettings(SrmSettings settings)
{
var lightMods = new List <StaticMod>();
var heavyMods = new Dictionary <IsotopeLabelType, List <StaticMod> >();
if (HasMatches)
{
foreach (var matchPair in Matches)
{
var structuralMod = matchPair.Value.StructuralMod;
StaticMod mod1 = structuralMod;
if (structuralMod != null && !lightMods.Contains(mod => mod.Equivalent(mod1)))
{
// Make all found structural mods variable, unless they are preexisting modifications.
if (!UserDefinedTypedMods.ContainsKey(structuralMod) || structuralMod.IsUserSet)
{
structuralMod = structuralMod.ChangeVariable(true);
}
// Set modification to be implicit if it appears to be implicit in the library.
if (!UserDefinedTypedMods.ContainsKey(structuralMod) && !IsVariableMod(structuralMod))
{
structuralMod = structuralMod.ChangeExplicit(false);
}
lightMods.Add(structuralMod);
}
var heavyMod = matchPair.Value.HeavyMod;
if (heavyMod == null)
{
continue;
}
IsotopeLabelType labelType;
if (!UserDefinedTypedMods.TryGetValue(heavyMod, out labelType))
{
labelType = DocDefHeavyLabelType;
}
heavyMod = heavyMod.ChangeExplicit(false);
if (!heavyMods.ContainsKey(labelType))
{
heavyMods.Add(labelType, new List <StaticMod> {
heavyMod
});
}
else if (!heavyMods[labelType].Contains(mod => mod.Equivalent(heavyMod)))
{
heavyMods[labelType].Add(heavyMod);
}
}
}
var typedModifications = new List <TypedModifications>();
foreach (var labelType in heavyMods.Keys)
{
typedModifications.Add(new TypedModifications(labelType, heavyMods[labelType]));
}
var mods = settings.PeptideSettings.Modifications;
return(new PeptideModifications(lightMods, mods.MaxVariableMods, mods.MaxNeutralLosses,
typedModifications, new[] { IsotopeLabelType.heavy }));
}
private Modification GenerateNewModification(StaticMod mod, char a)
{
return(new Modification(mod.ShortName ?? mod.Name, mod.Name, mod.MonoisotopicMass ?? 0.0,
mod.AverageMass ?? 0.0, a, !mod.IsVariable, mod.Losses?.Select(l => l.MonoisotopicMass).ToArray() ?? new double[0],
mod.Terminus.HasValue && mod.Terminus.Value == ModTerminus.N,
mod.Terminus.HasValue && mod.Terminus.Value == ModTerminus.C,
mod.UnimodId ?? 0, false));
}
public IsotopeModificationPermuter(StaticMod isotopeModification, bool simplePermutation, IsotopeLabelType fullHeavyLabelType, List <StaticMod> globalStaticMods, List <StaticMod> globalIsotopeMods)
{
IsotopeModification = isotopeModification;
SimplePermutation = simplePermutation;
FullyHeavyLabelType = fullHeavyLabelType;
GlobalStaticMods = globalStaticMods;
GlobalIsotopeMods = globalIsotopeMods;
}
private bool EnsureLinkedPeptide(StaticMod staticMod, int indexAA)
{
if (HasAppropriateLinkedPeptide(staticMod, indexAA))
{
return(true);
}
EditLinkedPeptide(indexAA);
return(HasAppropriateLinkedPeptide(staticMod, indexAA));
}
/// <summary>
/// Compares the modifications indicated in the sequence string to the calculated masses.
/// </summary>
/// <param name="seq">The modified sequence.</param>
/// <param name="calc">Calculator used to calculate the masses.</param>
/// <param name="calcLight">
/// Additional light calculator if necessary to isolate mass changes
/// caused by heavy modifications alone.
/// </param>
/// <returns>
/// True if the given calculators explain the modifications indicated on the sequence,
/// false otherwise.
/// </returns>
private bool EqualsModifications(string seq, IPrecursorMassCalc calc, IPrecursorMassCalc calcLight)
{
var modifications = Settings.PeptideSettings.Modifications;
bool structural = calcLight == null;
string aas = FastaSequence.StripModifications(seq);
foreach (var info in EnumerateSequenceInfos(seq, true))
{
int indexAA = info.IndexAA; // ReSharper
var aa = aas[indexAA];
var roundedTo = info.RoundedTo;
// If the user has indicated the modification by name, find that modification
// and calculate the mass.
double massKey;
if (info.Mass != null)
{
massKey = (double)info.Mass;
}
else
{
var info1 = info;
StaticMod modMatch = null;
int index;
if (structural &&
((index = modifications.StaticModifications.IndexOf(mod => Equals(mod.Name, info1.Name)))
!= -1))
{
modMatch = modifications.StaticModifications[index];
}
if (!structural &&
((index = modifications.HeavyModifications.IndexOf(mod => Equals(mod.Name, info1.Name)))
!= -1))
{
modMatch = modifications.HeavyModifications[index];
}
if (modMatch == null)
{
return(false);
}
roundedTo = DEFAULT_ROUNDING_DIGITS;
massKey = Math.Round(GetDefaultModMass(aa, modMatch), roundedTo);
}
double massMod = Math.Round(calc.GetAAModMass(aas[indexAA], indexAA, aas.Length), roundedTo);
// Subtract the mass difference of the light
// modifications to isolate the masses of the heavy modifications.
if (calcLight != null)
{
massMod -= Math.Round(calcLight.GetAAModMass(aas[indexAA], indexAA, aas.Length), roundedTo);
}
if (!Equals(massKey, massMod))
{
return(false);
}
}
return(true);
}
public void MultiLabelExplicitSerialTest()
{
// Create a simple document and add two peptides
SrmDocument document = new SrmDocument(SrmSettingsList.GetDefault());
const string pepSequence1 = "QFVLSCVILR";
const string pepSequence2 = "DIEVYCDGAITTK";
var reader = new StringReader(string.Join("\n", new[] { ">peptides1", pepSequence1, pepSequence2 }));
IdentityPath path;
document = document.ImportFasta(reader, true, IdentityPath.ROOT, out path);
Assert.AreEqual(2, document.PeptideCount);
// Add some modifications in two new label types
var modCarb = new StaticMod("Carbamidomethyl Cysteine", "C", null, "C2H3ON");
var modOther = new StaticMod("Another Cysteine", "C", null, "CO8N2");
var staticMods = new[] { modCarb, modOther };
var mod15N = new StaticMod("All 15N", null, null, null, LabelAtoms.N15, null, null);
var modK13C = new StaticMod("13C K", "K", ModTerminus.C, null, LabelAtoms.C13, null, null);
var modR13C = new StaticMod("13C R", "R", ModTerminus.C, null, LabelAtoms.C13, null, null);
var modV13C = new StaticMod("Heavy V", "V", null, null, LabelAtoms.C13 | LabelAtoms.N15, null, null);
var heavyMods = new[] { mod15N, modK13C, modR13C, modV13C };
var labelTypeAA = new IsotopeLabelType("heavy AA", IsotopeLabelType.FirstHeavy);
var labelTypeAll = new IsotopeLabelType("heavy All", IsotopeLabelType.FirstHeavy + 1);
var settings = document.Settings;
settings = settings.ChangePeptideModifications(mods =>
new PeptideModifications(mods.StaticModifications,
new[]
{
new TypedModifications(labelTypeAA, new[] { modK13C, modR13C }),
new TypedModifications(labelTypeAll, new[] { mod15N })
}));
document = document.ChangeSettings(settings);
Assert.AreEqual(6, document.PeptideTransitionGroupCount);
// Add modifications to light and heavy AA in the first peptide
path = document.GetPathTo((int)SrmDocument.Level.Molecules, 0);
var nodePepMod = (PeptideDocNode)document.FindNode(path);
var explicitMod = new ExplicitMods(nodePepMod.Peptide,
new[] { new ExplicitMod(pepSequence1.IndexOf('C'), modOther) },
new[] { new TypedExplicitModifications(nodePepMod.Peptide, labelTypeAA, new ExplicitMod[0]) });
document = document.ChangePeptideMods(path, explicitMod, staticMods, heavyMods);
Assert.AreEqual(5, document.PeptideTransitionGroupCount);
// Add a modification to heavy All in the second peptide
path = document.GetPathTo((int)SrmDocument.Level.Molecules, 1);
nodePepMod = (PeptideDocNode)document.FindNode(path);
explicitMod = new ExplicitMods(nodePepMod.Peptide, null,
new[] { new TypedExplicitModifications(nodePepMod.Peptide, labelTypeAll,
new[] { new ExplicitMod(pepSequence2.IndexOf('V'), modV13C) }) });
document = document.ChangePeptideMods(path, explicitMod, staticMods, heavyMods);
Assert.AreEqual(5, document.PeptideTransitionGroupCount);
AssertEx.Serializable(document, 3, AssertEx.DocumentCloned);
}
public void Add(char aa, StaticMod mod, bool structural, bool allowDuplicates)
{
if (_completed)
{
throw new InvalidOperationException(Resources.ModMassLookup_Add_Invalid_attempt_to_add_data_to_completed_MassLookup);
}
// If structural, store in lowercase AA.
_aaMassLookups[structural ? ToStructuralIndex(aa) : ToIsotopeIndex(aa)]
.Add(CALC.GetModMass(aa, mod), mod, allowDuplicates);
}
public void RemoveModification(StaticMod mod, IsotopeLabelType labelType)
{
if (MatcherPepMods.GetModificationTypes().Contains(labelType))
{
var newMods = MatcherPepMods.GetModifications(labelType)
.Where(existingMod => !existingMod.Equivalent(mod)).ToArray();
MatcherPepMods = MatcherPepMods.ChangeModifications(labelType, newMods);
}
MatchesUpdated = true;
}
