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 override void ReadXml(XmlReader reader)
{
// Read tag attributes
base.ReadXml(reader);
Fragment = reader.GetAttribute(ATTR.cut);
if (IsFragment)
{
Restrict = reader.GetAttribute(ATTR.no_cut);
Terminus = reader.GetAttribute(ATTR.sense, ToSeqTerminus);
MinFragmentLength = reader.GetNullableIntAttribute(ATTR.min_length) ??
DEFAULT_MIN_FRAGMENT_LENGTH;
}
else
{
var charges = TextUtil.ParseInts(reader.GetAttribute(ATTR.charges)); // Old version?
if (charges.Length > 1)
{
throw new InvalidDataException(Resources.MeasuredIon_ReadXml_Multiple_charge_states_for_custom_ions_are_no_longer_supported_);
}
var parsedIon = CustomIon.Deserialize(reader);
Adduct adduct;
if (charges.Any()) // Old style - fix it up a little for our revised ideas about custom ion ionization
{
adduct = Adduct.FromChargeNoMass(charges[0]);
if (string.IsNullOrEmpty(parsedIon.NeutralFormula)) // Adjust the user-supplied masses
{
SettingsCustomIon = new SettingsCustomIon(parsedIon.NeutralFormula, adduct,
Math.Round(parsedIon.MonoisotopicMass + charges[0] * BioMassCalc.MONOISOTOPIC.GetMass(BioMassCalc.H), SequenceMassCalc.MassPrecision), // Assume user provided neutral mass. Round new value easiest XML roundtripping.
Math.Round(parsedIon.AverageMass + charges[0] * BioMassCalc.AVERAGE.GetMass(BioMassCalc.H), SequenceMassCalc.MassPrecision), // Assume user provided neutral mass. Round new value easiest XML roundtripping.
parsedIon.Name);
}
else // Adjust the formula to include ion atoms
{
if (charges[0] > 1) // XML deserializer will have added an H already
{
var adductProtonated = Adduct.FromChargeProtonated(charges[0] - 1);
var formula = adductProtonated.ApplyToFormula(parsedIon.NeutralFormula);
parsedIon = new CustomIon(formula, adduct, parsedIon.MonoisotopicMass, parsedIon.AverageMass, Name);
}
}
}
else
{
adduct = Adduct.FromStringAssumeChargeOnly(reader.GetAttribute(ATTR.charge)); // Ionization mass is already in formula
}
if (SettingsCustomIon == null)
{
SettingsCustomIon = new SettingsCustomIon(parsedIon.NeutralFormula, adduct,
parsedIon.MonoisotopicMass,
parsedIon.AverageMass,
parsedIon.Name);
}
IsOptional = reader.GetBoolAttribute(ATTR.optional);
}
// Consume tag
reader.Read();
Validate();
}
private static Adduct GetChargeFromIndicator(string text, int i, out int foundAt)
{
var adduct = Adduct.FromChargeProtonated(i);
foundAt = FindChargeIndicatorPos(text, GetChargeIndicator(adduct));
if (foundAt == -1 && GetChargeSeparator(CultureInfo.CurrentCulture) != GetChargeSeparator(CultureInfo.InvariantCulture))
{
foundAt = FindChargeIndicatorPos(text, GetChargeIndicator(adduct, CultureInfo.InvariantCulture));
}
return(foundAt != -1 ? adduct : Adduct.EMPTY);
}
public PeptideDocNode PermuteModificationsOnPeptide(SrmDocument document, PeptideGroupDocNode peptideGroupDocNode,
PeptideDocNode peptideDocNode, List <IsotopeLabelType> partialLabelTypes)
{
if (SkipPeptide(peptideDocNode))
{
return(peptideDocNode);
}
var potentiallyModifiedResidues = PotentiallyModifiedResidues(peptideDocNode, IsotopeModification);
if (potentiallyModifiedResidues.Count == 0)
{
return(peptideDocNode);
}
// Create a document containing only one peptide so that "ChangePeptideMods" does not have to walk
// over a long list of peptides to see which modifications are in use.
var smallDocument = (SrmDocument)document.ChangeChildren(new DocNode[]
{ peptideGroupDocNode.ChangeChildren(new DocNode[] { peptideDocNode }) });
var newTypedExplicitModifications = PermuteTypedExplicitModifications(partialLabelTypes, peptideDocNode, potentiallyModifiedResidues);
var newExplicitMods = new ExplicitMods(peptideDocNode.Peptide, peptideDocNode.ExplicitMods?.StaticModifications, newTypedExplicitModifications);
var identityPath = new IdentityPath(peptideGroupDocNode.PeptideGroup, peptideDocNode.Peptide);
smallDocument = smallDocument.ChangePeptideMods(identityPath, newExplicitMods, false, GlobalStaticMods,
GlobalIsotopeMods);
peptideDocNode = (PeptideDocNode)smallDocument.FindPeptideGroup(peptideGroupDocNode.PeptideGroup).FindNode(peptideDocNode.Peptide);
var lightChargeStates = peptideDocNode.TransitionGroups.Where(tg => tg.IsLight).Select(tg => tg.PrecursorCharge).Distinct().ToList();
var chargeStatesByLabel =
peptideDocNode.TransitionGroups.ToLookup(tg => tg.LabelType, tg => tg.PrecursorCharge);
var transitionGroupsToAdd = new List <TransitionGroupDocNode>();
foreach (var typedExplicitModifications in newExplicitMods.GetHeavyModifications())
{
var labelType = typedExplicitModifications.LabelType;
foreach (var chargeState in lightChargeStates.Except(chargeStatesByLabel[labelType]))
{
var tranGroup = new TransitionGroup(peptideDocNode.Peptide, Adduct.FromChargeProtonated(chargeState), labelType);
TransitionDocNode[] transitions = peptideDocNode.GetMatchingTransitions(tranGroup, smallDocument.Settings, newExplicitMods);
var nodeGroup = new TransitionGroupDocNode(tranGroup, transitions);
nodeGroup = nodeGroup.ChangeSettings(smallDocument.Settings, peptideDocNode, newExplicitMods, SrmSettingsDiff.ALL);
transitionGroupsToAdd.Add(nodeGroup);
}
}
if (transitionGroupsToAdd.Any())
{
var newChildren = peptideDocNode.TransitionGroups.Concat(transitionGroupsToAdd).ToList();
newChildren.Sort(Peptide.CompareGroups);
peptideDocNode = (PeptideDocNode)peptideDocNode.ChangeChildren(newChildren.Cast <DocNode>().ToList());
}
return(peptideDocNode);
}
public SrmTransition GetModel(PepV01 peptide)
{
int offset = FragmentIon.OrdinalToOffset(FragmentType,
FragmentOrdinal, peptide.Length);
double mh = NeutralMass + BioMassCalc.MassProton;
FragmentIon fragment = new FragmentIon(peptide, FragmentType, offset, mh);
double start = StartRT ?? 0;
double stop = StopRT ?? 0;
return(new SrmTransition(fragment, CollisionEnergy,
DeclusteringPotential, start - stop,
Adduct.FromChargeProtonated(PrecursorCharge), Adduct.FromChargeProtonated(ProductCharge)));
}
/// <summary>
/// Calculates the matching charge within a tolerance for a mass, assuming (de)protonation.
/// </summary>
/// <param name="mass">The mass to calculate charge for (actually massH if !IsCustomIon)</param>
/// <param name="mz">The desired m/z value the charge should produce</param>
/// <param name="tolerance">How far off the actual m/z is allowed to be</param>
/// <param name="isCustomIon">Is this a custom ion formula?</param>
/// <param name="minCharge">Minimum charge to consider</param>
/// <param name="maxCharge">Maximum charge to consider</param>
/// <param name="massShifts">Possible mass shifts that may have been applied to decoys</param>
/// <param name="massShiftType"></param>
/// <param name="massShift">Mass shift required to to achieve this charge state or zero</param>
/// <param name="nearestCharge">closest matching charge, useful when return value is null</param>
/// <returns>A matching charge or null, in which case the closest non-matching charge can be found in the nearestCharge value.</returns>
public static Adduct CalcCharge(TypedMass mass, double mz, double tolerance, bool isCustomIon, int minCharge, int maxCharge,
ICollection <int> massShifts, MassShiftType massShiftType, out int massShift, out int nearestCharge)
{
Assume.IsTrue(minCharge <= maxCharge);
massShift = 0;
nearestCharge = 0;
double nearestDelta = double.MaxValue;
for (int i = minCharge; i <= maxCharge; i++)
{
if (i != 0) // Avoid z=0 if we're entertaining negative charge states
{
double calculatedMz = isCustomIon
? Adduct.FromChargeProtonated(i).MzFromNeutralMass(mass)
: SequenceMassCalc.GetMZ(mass, i);
double delta = mz - calculatedMz;
double deltaAbs = Math.Abs(delta);
int potentialShift = (int)Math.Round(deltaAbs);
double fractionalDelta = deltaAbs - potentialShift;
if (MatchMz(fractionalDelta, tolerance) && MatchMassShift(potentialShift, massShifts, massShiftType))
{
massShift = potentialShift;
if (delta < 0)
{
massShift = -massShift;
}
var result = i;
nearestCharge = i;
return(Adduct.FromCharge(result, isCustomIon ? Adduct.ADDUCT_TYPE.non_proteomic : Adduct.ADDUCT_TYPE.proteomic));
}
if (deltaAbs < nearestDelta)
{
nearestDelta = deltaAbs;
nearestCharge = i;
}
// If the charge is positive and the calculated m/z is smaller than the desired m/z
// increasing the charge further cannot possibly produce a match
if (massShiftType == MassShiftType.none && minCharge > 0 && delta > 0)
{
break;
}
}
}
Debug.Assert(nearestCharge != 0); // Could only happen if min > max
return(Adduct.EMPTY);
}
public void ChargeStateTextTest()
{
int min = Transition.MIN_PRODUCT_CHARGE, max = Transition.MAX_PRODUCT_CHARGE;
for (int i = min; i < max; i++)
{
ValidateChargeText(i, Transition.GetChargeIndicator(Adduct.FromChargeProtonated(i)));
ValidateChargeText(-i, Transition.GetChargeIndicator(Adduct.FromChargeProtonated(-i)));
ValidateChargeText(i, Transition.GetChargeIndicator(Adduct.FromChargeProtonated(i), CultureInfo.InvariantCulture));
ValidateChargeText(-i, Transition.GetChargeIndicator(Adduct.FromChargeProtonated(-i), CultureInfo.InvariantCulture));
ValidateChargeText(i, GetLongFormChargeIndicator(i));
ValidateChargeText(-i, GetLongFormChargeIndicator(-i));
}
}
private static void ValidateChargeText(int charge, string chargeText)
{
const string pepText = "PEPTIDER";
int min = Transition.MIN_PRODUCT_CHARGE, max = Transition.MAX_PRODUCT_CHARGE;
Assert.AreEqual(pepText, Transition.StripChargeIndicators(pepText + chargeText, min, max),
"Unable to round trip charge text " + chargeText);
Assert.AreEqual(Adduct.FromChargeProtonated(charge), Transition.GetChargeFromIndicator(chargeText, min, max));
// If the charge indicator contains a space, make sure it is not necessary to be interpreted correctly
if (chargeText.Contains(' '))
{
ValidateChargeText(charge, chargeText.Replace(" ", string.Empty));
}
}
public MockTranGroupPeakData(IList <ITransitionPeakData <TPeak> > transitionPeakData,
bool isStandard = false,
int?charge = null,
IsotopeLabelType labelType = null)
{
TransitionPeakData = transitionPeakData;
Ms1TranstionPeakData = TransitionPeakData.Where(t => t.NodeTran != null && t.NodeTran.IsMs1).ToArray();
Ms2TranstionPeakData = TransitionPeakData.Where(t => t.NodeTran != null && !t.NodeTran.IsMs1).ToArray();
IsStandard = isStandard;
var libInfo = new ChromLibSpectrumHeaderInfo("", 0);
var peptide = new Peptide(null, "AVVAVVA", null, null, 0);
NodeGroup = new TransitionGroupDocNode(new TransitionGroup(peptide, Adduct.FromChargeProtonated(charge ?? 2), labelType), null, null,
null, libInfo, ExplicitTransitionGroupValues.EMPTY, null, new TransitionDocNode[0], true);
}
public static string StripChargeIndicators(string text, int min, int max)
{
if (!MayHaveChargeIndicator(text))
{
return(text);
}
var sequences = new List <string>();
foreach (var line in text.Split('\n').Select(seq => seq.Trim()))
{
int chargePos = -1;
for (int i = max; i >= min; i--)
{
// Handle negative charges
var charge = GetChargeIndicator(Adduct.FromChargeProtonated(-i));
if (line.EndsWith(charge))
{
chargePos = line.LastIndexOf(charge, StringComparison.CurrentCulture);
break;
}
charge = GetChargeIndicator(Adduct.FromChargeProtonated(i));
if (line.EndsWith(charge))
{
chargePos = line.LastIndexOf(charge, StringComparison.CurrentCulture);
break;
}
}
if (chargePos == -1)
{
// Check for adduct description
Adduct adduct;
var adductStart = FindAdductDescription(line, out adduct);
if (adductStart >= 0)
{
var z = Math.Abs(adduct.AdductCharge);
if (min <= z && z <= max)
{
chargePos = adductStart;
}
}
}
sequences.Add(chargePos == -1 ? line : line.Substring(0, chargePos));
}
return(TextUtil.LineSeparate(sequences));
}
private static void TestUse()
{
// Accept unmodified
TestRefineListDlg(dlg => dlg.PeptidesText = PEPTIDE_UNMODIFIED, 2, 1, 8, 22);
// Accept all modified
TestRefineListDlg(dlg => dlg.PeptidesText = PEPTIDE_MODIFIED, 2, 4, 32, 96);
// Remove empty proteins
TestRefineListDlg(dlg =>
{
dlg.PeptidesText = PEPTIDE_UNMODIFIED;
dlg.RemoveEmptyProteins = true;
},
1, 1, 8, 22);
// Remove all but specific charge states
string peptideCharges = TextUtil.LineSeparate(
PEPTIDE_MODIFIED + Transition.GetChargeIndicator(Adduct.FromChargeProtonated(2)),
PEPTIDE_MODIFIED + Transition.GetChargeIndicator(Adduct.FromChargeProtonated(3)),
PEPTIDE_UNMODIFIED + Transition.GetChargeIndicator(Adduct.FromChargeProtonated(5)));
TestRefineListDlg(dlg => dlg.PeptidesText = peptideCharges,
document =>
{
var peptides = document.Peptides.ToArray();
for (int i = 0; i < 4; i++)
{
Assert.IsTrue(peptides[i].TransitionGroups.All(nodeGroup =>
nodeGroup.TransitionGroup.PrecursorAdduct.AdductCharge == 2 ||
nodeGroup.TransitionGroup.PrecursorAdduct.AdductCharge == 3));
}
Assert.IsTrue(peptides[4].TransitionGroups.All(nodeGroup =>
nodeGroup.TransitionGroup.PrecursorAdduct.AdductCharge == 5));
},
2, 5, 18, 54);
// Modification specific acceptance
string peptideMods = TextUtil.LineSeparate(
PEPTIDE_MODIFIED.Insert(6, "[57]"),
PEPTIDE_MODIFIED.Insert(6, "[+57]").Insert(4, "[+" + 79.966331 + "]").Insert(3, string.Format("[+{0:F01}]", 80)),
PEPTIDE_UNMODIFIED);
TestRefineListDlg(dlg =>
{
dlg.PeptidesText = peptideMods;
dlg.RemoveEmptyProteins = dlg.MatchModified = true;
}, 1, 3, 24, 70);
}
public static Adduct GetChargeFromIndicator(string text, int min, int max, out int foundAt)
{
foundAt = -1;
if (!MayHaveChargeIndicator(text))
{
return(Adduct.EMPTY);
}
// Handle runs of charge characters no matter how long, because users guess this should work
foundAt = FindChargeSymbolRepeatStart('+', text, min, max);
if (foundAt != -1)
{
return(Adduct.FromChargeProtonated(text.Length - foundAt));
}
foundAt = FindChargeSymbolRepeatStart('-', text, min, max);
if (foundAt != -1)
{
return(Adduct.FromChargeProtonated(foundAt - text.Length));
}
Adduct adduct;
for (int i = max; i >= min; i--)
{
adduct = GetChargeFromIndicator(text, i, out foundAt);
if (!adduct.IsEmpty)
{
return(adduct);
}
adduct = GetChargeFromIndicator(text, -i, out foundAt);
if (!adduct.IsEmpty)
{
return(adduct);
}
}
foundAt = FindAdductDescription(text, out adduct);
if (foundAt != -1)
{
return(adduct);
}
return(Adduct.EMPTY);
}
private static int FindChargeIndicatorPos(string line, int min, int max, CultureInfo cultureInfo)
{
for (int i = max; i >= min; i--)
{
// Handle negative charges
int pos = FindChargeIndicatorPos(line, GetChargeIndicator(Adduct.FromChargeProtonated(-i), cultureInfo));
if (pos != -1)
{
return(pos);
}
// Handle positive charges
pos = FindChargeIndicatorPos(line, GetChargeIndicator(Adduct.FromChargeProtonated(i), cultureInfo));
if (pos != -1)
{
return(pos);
}
}
return(-1);
}
private void LoadPeptides(IEnumerable <DbIonMobilityPeptide> peptides)
{
var dictLibrary = new Dictionary <LibKey, DbIonMobilityPeptide>();
foreach (var pep in peptides)
{
var dict = dictLibrary;
try
{
DbIonMobilityPeptide ignored;
var adduct = pep.GetPrecursorAdduct();
if (adduct.IsEmpty)
{
// Older formats didn't consider charge to be a factor is CCS, so just fake up M+H, M+2H and M+3H
for (int z = 1; z <= 3; z++)
{
var newPep = new DbIonMobilityPeptide(pep.GetNormalizedModifiedSequence(),
Adduct.FromChargeProtonated(z), pep.CollisionalCrossSection, pep.HighEnergyDriftTimeOffsetMsec);
var key = newPep.GetLibKey();
if (!dict.TryGetValue(key, out ignored))
{
dict.Add(key, newPep);
}
}
}
else
{
var key = pep.GetLibKey();
if (!dict.TryGetValue(key, out ignored))
{
dict.Add(key, pep);
}
}
}
catch (ArgumentException)
{
}
}
DictLibrary = dictLibrary;
}
/// <summary>
/// Calculates the matching charge within a tolerance for a mass, assuming (de)protonation.
/// </summary>
/// <param name="mass">The mass to calculate charge for (actually massH if !IsCustomIon)</param>
/// <param name="mz">The desired m/z value the charge should produce</param>
/// <param name="tolerance">How far off the actual m/z is allowed to be</param>
/// <param name="isCustomIon">Is this a custom ion formula?</param>
/// <param name="minCharge">Minimum charge to consider</param>
/// <param name="maxCharge">Maximum charge to consider</param>
/// <param name="massShifts">Possible mass shifts that may have been applied to decoys</param>
/// <param name="massShiftType"></param>
/// <param name="massShift">Mass shift required to to achieve this charge state or zero</param>
/// <param name="nearestCharge">closest matching charge, useful when return value is null</param>
/// <returns>A matching charge or null, in which case the closest non-matching charge can be found in the nearestCharge value.</returns>
public static Adduct CalcCharge(TypedMass mass, double mz, double tolerance, bool isCustomIon, int minCharge, int maxCharge,
ICollection <int> massShifts, MassShiftType massShiftType, out int massShift, out int nearestCharge)
{
Assume.IsTrue(minCharge <= maxCharge);
massShift = 0;
nearestCharge = 0;
double nearestDelta = double.MaxValue;
for (int i = minCharge; i <= maxCharge; i++)
{
if (i != 0) // Avoid z=0 if we're entertaining negative charge states
{
double delta = mz - (isCustomIon ? Adduct.FromChargeProtonated(i).MzFromNeutralMass(mass) : SequenceMassCalc.GetMZ(mass, i));
double deltaAbs = Math.Abs(delta);
int potentialShift = (int)Math.Round(deltaAbs);
double fractionalDelta = deltaAbs - potentialShift;
if (MatchMz(fractionalDelta, tolerance) && MatchMassShift(potentialShift, massShifts, massShiftType))
{
massShift = potentialShift;
if (delta < 0)
{
massShift = -massShift;
}
var result = i;
nearestCharge = i;
return(Adduct.FromChargeProtonated(result));
}
if (deltaAbs < nearestDelta)
{
nearestDelta = deltaAbs;
nearestCharge = i;
}
}
}
Debug.Assert(nearestCharge != 0); // Could only happen if min > max
return(Adduct.EMPTY);
}
public MockTranPeakData(double[] data,
IonType ionType = IonType.a,
IsotopeLabelType labelType = null,
int?charge = null,
double?massError = null,
double libIntensity = 0,
double?isotopeProportion = null)
{
if (labelType == null)
{
labelType = IsotopeLabelType.light;
}
PeakData = new MockPeakData(data, massError) as TPeak;
var peptide = new Peptide(null, "AVVAVVA", null, null, 0);
charge = charge ?? 2;
var tranGroup = new TransitionGroup(peptide, Adduct.FromChargeProtonated(charge), labelType);
int offset = ionType == IonType.precursor ? 6 : 0;
var isotopeInfo = isotopeProportion == null ? null : new TransitionIsotopeDistInfo(1, (float)isotopeProportion);
NodeTran = new TransitionDocNode(new Transition(tranGroup, ionType, offset, 0, Adduct.FromChargeProtonated(charge), null),
null, TypedMass.ZERO_MONO_MASSH, new TransitionDocNode.TransitionQuantInfo(isotopeInfo, new TransitionLibInfo(1, (float)libIntensity), true));
}
public static Adduct GetChargeFromIndicator(string text, int min, int max, out int foundAt)
{
foundAt = -1;
if (!MayHaveChargeIndicator(text))
{
return(Adduct.EMPTY);
}
Adduct adduct;
for (int i = max; i >= min; i--)
{
// Handle negative charges
adduct = Adduct.FromChargeProtonated(-i);
var chargeIndicator = GetChargeIndicator(adduct);
if (text.EndsWith(chargeIndicator))
{
foundAt = text.Length - chargeIndicator.Length;
return(adduct);
}
adduct = Adduct.FromChargeProtonated(i);
chargeIndicator = GetChargeIndicator(adduct);
if (text.EndsWith(chargeIndicator))
{
foundAt = text.Length - chargeIndicator.Length;
return(adduct);
}
}
var adductStart = FindAdductDescription(text, out adduct);
if (adductStart >= 0)
{
foundAt = adductStart;
return(adduct);
}
return(Adduct.EMPTY);
}
private void TestAdductOperators()
{
// Test some underlying formula handling for fanciful user-supplied values
Assert.IsTrue(Molecule.AreEquivalentFormulas("C10H30Si5O5H-CH4", "C9H27O5Si5"));
Assert.AreEqual("C7H27O5Si4", BioMassCalc.MONOISOTOPIC.FindFormulaIntersection(new[] { "C8H30Si5O5H-CH4", "C9H27O5Si4", "C9H27O5Si5Na" }));
Assert.AreEqual("C7H27O5Si4", BioMassCalc.MONOISOTOPIC.FindFormulaIntersectionUnlabeled(new[] { "C7C'H30Si5O5H-CH4", "C9H27O5Si4", "C9H25H'2O5Si5Na" }));
// There is a difference between a proteomic adduct and non proteomic, primarily in how they display
Assert.AreEqual(Adduct.FromStringAssumeChargeOnly("M+H"), Adduct.M_PLUS_H);
Assert.AreEqual(Adduct.FromStringAssumeProtonatedNonProteomic("1"), Adduct.M_PLUS_H);
Assert.AreEqual(Adduct.FromStringAssumeChargeOnly("1"), Adduct.M_PLUS);
Assert.AreEqual(Adduct.FromStringAssumeProtonatedNonProteomic("M+H"), Adduct.M_PLUS_H);
Assert.AreEqual(Adduct.FromStringAssumeProtonated("1"), Adduct.SINGLY_PROTONATED);
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M+H"), Adduct.SINGLY_PROTONATED);
Assert.AreEqual(Adduct.FromStringAssumeChargeOnly("M+H").AsFormula(), Adduct.SINGLY_PROTONATED.AsFormula()); // But the underlying chemistry is the same
Assert.AreEqual(Adduct.FromStringAssumeProtonated("[M+S]+"), Adduct.FromStringAssumeProtonated("M+S").ChangeCharge(1));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M(-1.234)+2Na"), Adduct.FromStringAssumeProtonated("M(-1.234)+3Na").ChangeCharge(2));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M1.234+2Na"), Adduct.FromStringAssumeProtonated("M1.234+3Na").ChangeCharge(2));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M2Cl37-2Na"), Adduct.FromStringAssumeProtonated("M2Cl37+3Na").ChangeCharge(-2));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M1.234-2Na"), Adduct.FromStringAssumeProtonated("M1.234+3Na").ChangeCharge(-2));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M(-1.234)-2Na"), Adduct.FromStringAssumeProtonated("M(-1.234)+3Na").ChangeCharge(-2));
Assert.IsFalse(Adduct.M_PLUS_H.IsProteomic);
Assert.IsTrue(Adduct.M_PLUS_H.IsProtonated);
Assert.IsTrue(Adduct.SINGLY_PROTONATED.IsProteomic);
Assert.IsTrue(Adduct.SINGLY_PROTONATED.IsProtonated);
Assert.IsFalse(Adduct.SINGLY_PROTONATED.IsEmpty);
Assert.IsFalse(Adduct.EMPTY.IsProteomic);
Assert.IsTrue(Adduct.EMPTY.IsEmpty);
// Exercise the ability to work with masses and isotope labels
Assert.IsTrue(ReferenceEquals(Adduct.SINGLY_PROTONATED, Adduct.SINGLY_PROTONATED.Unlabeled));
var nolabel = Adduct.FromStringAssumeProtonated("M-2Na");
var label = Adduct.FromStringAssumeProtonated("M2Cl37-2Na");
Assert.AreEqual(nolabel, label.Unlabeled);
Assert.IsTrue(ReferenceEquals(nolabel, nolabel.Unlabeled));
Assert.IsFalse(nolabel.MassFromMz(300.0, MassType.Monoisotopic).IsHeavy());
Assert.IsFalse(label.MassFromMz(300.0, MassType.Monoisotopic).IsHeavy());
Assert.IsTrue(label.MassFromMz(300.0, MassType.MonoisotopicHeavy).IsHeavy());
Assert.IsTrue(label.MassFromMz(300.0, MassType.Monoisotopic).IsMonoIsotopic());
Assert.IsFalse(nolabel.MassFromMz(300.0, MassType.Average).IsHeavy());
Assert.IsFalse(label.MassFromMz(300.0, MassType.Average).IsHeavy());
Assert.IsTrue(label.MassFromMz(300.0, MassType.AverageHeavy).IsHeavy());
Assert.IsTrue(label.MassFromMz(300.0, MassType.Average).IsAverage());
var massHeavy = label.ApplyToMass(new TypedMass(300, MassType.MonoisotopicHeavy)); // Will not have isotope effect added in mz calc, as it's already heavy
var massLight = label.ApplyToMass(new TypedMass(300, MassType.Monoisotopic)); // Will have isotope effect added in mz calc
Assert.AreNotEqual(massHeavy, massLight);
Assert.AreNotEqual(label.MzFromNeutralMass(massHeavy), label.MzFromNeutralMass(massLight));
Assert.IsTrue(Adduct.PossibleAdductDescriptionStart("["));
Assert.IsTrue(Adduct.PossibleAdductDescriptionStart("M"));
Assert.IsTrue(Adduct.PossibleAdductDescriptionStart("[2M+CH3COO]"));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M+2CH3COO"), Adduct.FromStringAssumeProtonated("M+CH3COO").ChangeCharge(-2));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M-2CH3COO"), Adduct.FromStringAssumeProtonated("M+CH3COO").ChangeCharge(2));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M-2Na"), Adduct.FromStringAssumeProtonated("M+Na").ChangeCharge(-2));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M+Na"), Adduct.FromStringAssumeProtonated("M+Na").ChangeCharge(1));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M+2Na"), Adduct.FromStringAssumeProtonated("M+Na").ChangeCharge(2));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M+2Na"), Adduct.FromStringAssumeProtonated("M+3Na").ChangeCharge(2));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M2Cl37+2Na"), Adduct.FromStringAssumeProtonated("M2Cl37+3Na").ChangeCharge(2));
AssertEx.ThrowsException <InvalidOperationException>(() => Adduct.FromStringAssumeProtonated("M+2Na-H").ChangeCharge(2)); // Too complex to adjust formula
AssertEx.ThrowsException <InvalidOperationException>(() => Adduct.FromStringAssumeProtonatedNonProteomic("[M2")); // Seen in the wild, wasn't handled well
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M++++").AdductCharge, Adduct.FromChargeNoMass(4).AdductCharge);
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M+4"), Adduct.FromChargeNoMass(4));
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M--").AdductCharge, Adduct.FromChargeNoMass(-2).AdductCharge);
Assert.AreEqual(Adduct.FromStringAssumeProtonated("M-2"), Adduct.FromChargeNoMass(-2));
Assert.IsTrue(ReferenceEquals(Adduct.FromStringAssumeChargeOnly("M-"), Adduct.FromChargeNoMass(-1))); // Both should return Adduct.M_MINUS
Assert.IsTrue(ReferenceEquals(Adduct.FromStringAssumeChargeOnly("M+"), Adduct.FromChargeNoMass(1))); // Both should return Adduct.M_PLUS
Assert.IsTrue(ReferenceEquals(Adduct.FromStringAssumeChargeOnly("[M+]"), Adduct.FromChargeNoMass(1))); // Both should return Adduct.M_PLUS
Assert.IsTrue(ReferenceEquals(Adduct.FromStringAssumeChargeOnly("M-H"), Adduct.M_MINUS_H));
Assert.IsTrue(ReferenceEquals(Adduct.FromStringAssumeChargeOnly("M+H"), Adduct.M_PLUS_H));
var a = Adduct.FromChargeProtonated(-1);
var aa = Adduct.FromStringAssumeProtonated("M+CH3COO");
var b = Adduct.FromChargeProtonated(2);
var bb = Adduct.FromChargeProtonated(2);
var bbb = Adduct.FromChargeProtonated(2);
var bbbb = Adduct.FromChargeProtonated(2);
var c = Adduct.FromChargeProtonated(3);
var cc = Adduct.FromStringAssumeChargeOnly("M+3H");
var ccc = Adduct.FromStringAssumeChargeOnly("[M+3H]");
Assert.AreEqual(a.AdductCharge, aa.AdductCharge);
Assert.IsTrue(b == bb);
Assert.IsTrue(b == bbb);
Assert.IsTrue(ReferenceEquals(bbb, bbbb));
Assert.IsTrue(c.AdductCharge == cc.AdductCharge);
Assert.IsFalse(c == cc);
Assert.IsTrue(c != cc);
Assert.IsTrue(cc == ccc);
Assert.IsTrue(a < aa);
Assert.IsTrue(a < b);
Assert.IsTrue(b > a);
Assert.IsTrue(b != a);
var sorted = new List <Adduct> {
a, aa, b, bb, bbb, bbbb, c, cc, ccc
};
var unsorted = new List <Adduct> {
bb, aa, ccc, b, c, bbb, a, bbbb, cc
};
Assert.IsFalse(sorted.SequenceEqual(unsorted));
unsorted.Sort();
Assert.IsTrue(sorted.SequenceEqual(unsorted));
var ints = new AdductMap <int>();
Assert.AreEqual(0, ints[a]);
ints[a] = 7;
Assert.AreEqual(7, ints[a]);
var adducts = new AdductMap <Adduct>();
Assert.AreEqual(null, adducts[a]);
adducts[a] = b;
Assert.AreEqual(b, adducts[a]);
adducts[a] = c;
Assert.AreEqual(c, adducts[a]);
var d = Adduct.FromStringAssumeProtonated("[2M+3H]");
var dd = Adduct.FromStringAssumeProtonated("[M+3H]");
var ddd = Adduct.FromStringAssumeProtonated("[M-Na]");
Assert.IsTrue(d.ChangeMassMultiplier(1).SameEffect(dd));
Assert.IsTrue(dd.ChangeMassMultiplier(2).SameEffect(d));
Assert.AreEqual(dd.ChangeIonFormula("-Na"), ddd);
Assert.AreEqual(d.ChangeMassMultiplier(1).ChangeIonFormula("-Na"), ddd);
CheckLabel(BioMassCalc.Cl37);
CheckLabel(BioMassCalc.Br81);
CheckLabel(BioMassCalc.S33);
CheckLabel(BioMassCalc.S34);
CheckLabel(BioMassCalc.P32);
CheckLabel(BioMassCalc.C14);
CheckLabel(BioMassCalc.O17);
CheckLabel(BioMassCalc.O18);
var tips = Adduct.Tips;
foreach (var nickname in Adduct.DICT_ADDUCT_NICKNAMES)
{
Assert.IsTrue(tips.Contains(nickname.Key));
}
foreach (var nickname in Adduct.DICT_ADDUCT_ISOTOPE_NICKNAMES)
{
Assert.IsTrue(tips.Contains(nickname.Key));
}
}
protected override void DoTest()
{
RunUI(() => SkylineWindow.OpenFile(TestFilesDir.GetTestPath("CE_Vantage_15mTorr_scheduled_mini_withMod.sky")));
WaitForGraphs();
RunUI(() =>
{
SequenceTree sequenceTree = SkylineWindow.SequenceTree;
// Test single node copy.
sequenceTree.ExpandAll();
sequenceTree.KeysOverride = Keys.None;
sequenceTree.SelectedNode = sequenceTree.Nodes[0];
SkylineWindow.Copy();
CheckCopiedNodes(0, 1);
// Test multiple selection copy.
sequenceTree.KeysOverride = Keys.Shift;
sequenceTree.SelectedNode = sequenceTree.Nodes[1];
SkylineWindow.Copy();
// Test multiple selection disjoint, reverse order copy.
CheckCopiedNodes(0, 1);
Assert.AreSame(sequenceTree, SkylineWindow.SequenceTree);
sequenceTree.KeysOverride = Keys.None;
sequenceTree.SelectedNode = sequenceTree.Nodes[1].Nodes[0];
sequenceTree.KeysOverride = Keys.Control;
sequenceTree.SelectedNode = sequenceTree.Nodes[0].Nodes[0];
SkylineWindow.Copy();
// After copying in reverse order, reselect the nodes in sorted order so we don't have to
// sort them in the test code.
sequenceTree.KeysOverride = Keys.None;
sequenceTree.SelectedNode = sequenceTree.Nodes[0];
sequenceTree.SelectedNode = sequenceTree.Nodes[0].Nodes[0];
sequenceTree.KeysOverride = Keys.Control;
sequenceTree.SelectedNode = sequenceTree.Nodes[1].Nodes[0];
Assert.AreSame(sequenceTree, SkylineWindow.SequenceTree);
CheckCopiedNodes(1, 2);
// Test no space between parent and descendents if immediate child is not selected.
sequenceTree.KeysOverride = Keys.None;
sequenceTree.SelectedNode = sequenceTree.Nodes[0];
sequenceTree.KeysOverride = Keys.Control;
sequenceTree.SelectedNode = sequenceTree.Nodes[0].Nodes[0].Nodes[0].Nodes[0];
sequenceTree.SelectedNode = sequenceTree.Nodes[0].Nodes[0].Nodes[0].Nodes[2];
SkylineWindow.Copy();
CheckCopiedNodes(0, 1);
// Test paste menu item enabled, copy menu item disabled when dummy node is selected.
sequenceTree.KeysOverride = Keys.None;
sequenceTree.SelectedNode =
sequenceTree.Nodes[SkylineWindow.SequenceTree.Nodes.Count - 1];
Assert.IsFalse(SkylineWindow.CopyMenuItemEnabled(), "Copy menu should not be enabled");
Assert.IsTrue(SkylineWindow.PasteMenuItemEnabled());
// Test FASTA sequence copy HTML formatting
sequenceTree.SelectedNode = sequenceTree.Nodes[0];
SkylineWindow.Copy();
string clipboardHtml = GetClipboardHtml();
Assert.AreEqual(4, Regex.Matches(clipboardHtml, "<font style=\"font-weight: bold").Count);
Assert.AreEqual(4, Regex.Matches(clipboardHtml, "</font>").Count);
Assert.AreEqual(1, Regex.Matches(clipboardHtml, "color: blue").Count);
sequenceTree.SelectedNode = sequenceTree.Nodes[1];
SkylineWindow.Copy();
clipboardHtml = GetClipboardHtml();
Assert.AreEqual(19, Regex.Matches(clipboardHtml, "<font style=\"font-weight: bold").Count);
Assert.AreEqual(19, Regex.Matches(clipboardHtml, "</font>").Count);
Assert.AreEqual(2, Regex.Matches(clipboardHtml, "color: blue").Count);
sequenceTree.SelectedNode = sequenceTree.Nodes[2];
SkylineWindow.Copy();
clipboardHtml = GetClipboardHtml();
Assert.AreEqual(18, Regex.Matches(clipboardHtml, "<font style=\"font-weight: bold").Count);
Assert.AreEqual(18, Regex.Matches(clipboardHtml, "</font>").Count);
Assert.AreEqual(2, Regex.Matches(clipboardHtml, "color: blue").Count);
// Test clipboard HTML contains formatting for modified peptides.
sequenceTree.SelectedNode = sequenceTree.Nodes[3].Nodes[0];
SkylineWindow.Copy();
clipboardHtml = GetClipboardHtml();
Assert.IsTrue(clipboardHtml.Contains("font") && clipboardHtml.Contains("color"));
});
// Paste a protein list
var document = WaitForDocumentLoaded();
RunUI(() =>
{
SetClipboardText(PROTEINLIST_CLIPBOARD_TEXT);
SkylineWindow.Paste();
});
var docPaste = WaitForDocumentChange(document);
Assert.AreEqual(document.PeptideGroupCount + 3, docPaste.PeptideGroupCount);
Assert.AreEqual("P23978", docPaste.PeptideGroups.Last().ProteinMetadata.Accession); // Did builtin IPI conversion work?
// Paste an invalid protein list
RunDlg <MessageDlg>(() =>
{
SetClipboardText(PROTEINLIST_CLIPBOARD_TEXT.Replace("MDAL", "***"));
SkylineWindow.Paste();
},
msgDlg => msgDlg.OkDialog());
Assert.AreSame(docPaste, WaitForProteinMetadataBackgroundLoaderCompletedUI());
// Test border case where protein/peptide/transition list contains a blank line
// Should give generic error, not crash
RunDlg <MessageDlg>(() =>
{
SetClipboardText(PROTEIN_LIST_BAD_FORMAT);
SkylineWindow.Paste();
},
msgDlg =>
{
Assert.AreEqual(msgDlg.Message, Resources.CopyPasteTest_DoTest_Could_not_read_the_pasted_transition_list___Transition_list_must_be_in_separated_columns_and_cannot_contain_blank_lines_);
msgDlg.OkDialog();
});
// Paste peptides
var precursorAdduct = Adduct.DOUBLY_PROTONATED;
List <Tuple <string, int> > peptidePaste = new List <Tuple <string, int> >
{
new Tuple <string, int>("FVEGLPINDFSR", 3),
new Tuple <string, int>("FVEGLPINDFSR", 2),
new Tuple <string, int>("FVEGLPINDFSR", 0),
new Tuple <string, int>("DLNELQALIEAHFENR", 0),
new Tuple <string, int>(string.Format("C[+{0:F01}]QPLELAGLGFAELQDLC[+{1:F01}]R", 57.0, 57.0), 3),
new Tuple <string, int>("PEPTIDER", 5),
new Tuple <string, int>("PEPTIDER", 15)
};
var peptidePasteSb = new StringBuilder();
foreach (var pep in peptidePaste)
{
peptidePasteSb.AppendLine(pep.Item1 + Transition.GetChargeIndicator(Adduct.FromChargeProtonated(pep.Item2)));
}
RunUI(() =>
{
SkylineWindow.NewDocument(true);
document = SkylineWindow.Document;
document = document.ChangeSettings(document.Settings.ChangeTransitionFilter(f => f.ChangePeptidePrecursorCharges(new[] { precursorAdduct })));
SetClipboardText(peptidePasteSb.ToString());
SkylineWindow.Paste();
});
document = WaitForDocumentChange(document);
Assert.AreEqual(peptidePaste.Count, document.PeptideTransitionGroupCount);
for (int i = 0; i < document.PeptideTransitionGroupCount; i++)
{
TransitionGroupDocNode transition = document.PeptideTransitionGroups.ElementAt(i);
string seq = transition.TransitionGroup.Peptide.Sequence;
var charge = transition.PrecursorAdduct.AdductCharge;
Assert.AreEqual(FastaSequence.StripModifications(peptidePaste[i].Item1), seq);
var pastedCharge = peptidePaste[i].Item2;
Assert.AreEqual(pastedCharge != 0 ? pastedCharge : precursorAdduct.AdductCharge, charge);
}
// Undo paste
RunUI(() => SkylineWindow.Undo());
document = WaitForDocumentChange(document);
// Change precursor charges
Adduct[] precursorCharges = { Adduct.DOUBLY_PROTONATED, Adduct.TRIPLY_PROTONATED, Adduct.QUADRUPLY_PROTONATED };
RunUI(() => SkylineWindow.ModifyDocument("Change precursor charges", doc => doc.ChangeSettings((document.Settings.ChangeTransitionFilter(f => f.ChangePeptidePrecursorCharges(precursorCharges))))));
document = WaitForDocumentChange(document);
// Re-paste in peptides
RunUI(() => SkylineWindow.Paste());
document = WaitForDocumentChange(document);
int curTransitionGroup = 0;
foreach (var peptide in peptidePaste)
{
if (peptide.Item2 > 0)
{
// Pasted peptides with a charge indicator should have a single precursor with the specified charge state
TransitionGroupDocNode group = document.PeptideTransitionGroups.ElementAt(curTransitionGroup++);
string seq = group.TransitionGroup.Peptide.Sequence;
var charge = group.PrecursorAdduct.AdductCharge;
Assert.AreEqual(FastaSequence.StripModifications(peptide.Item1), seq);
var pastedCharge = peptide.Item2;
Assert.AreEqual(pastedCharge, charge);
}
else
{
// Pasted peptides with no charge indicator should have a precursor for every charge state in transition filter settings
for (int j = 0; j < precursorCharges.Count(); j++)
{
TransitionGroupDocNode group = document.PeptideTransitionGroups.ElementAt(curTransitionGroup++);
string seq = group.TransitionGroup.Peptide.Sequence;
var charge = group.PrecursorAdduct;
Assert.AreEqual(FastaSequence.StripModifications(peptide.Item1), seq);
Assert.AreEqual(precursorCharges[j], charge);
}
}
}
Assert.AreEqual(curTransitionGroup, document.PeptideTransitionGroupCount);
}
public static TransitionDocNode FromTransitionProto(AnnotationScrubber scrubber, SrmSettings settings,
TransitionGroup group, ExplicitMods mods, IsotopeDistInfo isotopeDist, ExplicitTransitionValues pre422ExplicitTransitionValues,
SkylineDocumentProto.Types.Transition transitionProto)
{
var stringPool = scrubber.StringPool;
IonType ionType = DataValues.FromIonType(transitionProto.FragmentType);
MeasuredIon measuredIon = null;
if (transitionProto.MeasuredIonName != null)
{
measuredIon = settings.TransitionSettings.Filter.MeasuredIons.SingleOrDefault(
i => i.Name.Equals(transitionProto.MeasuredIonName.Value));
if (measuredIon == null)
{
throw new InvalidDataException(string.Format(Resources.TransitionInfo_ReadXmlAttributes_The_reporter_ion__0__was_not_found_in_the_transition_filter_settings_, transitionProto.MeasuredIonName));
}
ionType = IonType.custom;
}
bool isCustom = Transition.IsCustom(ionType, group);
bool isPrecursor = Transition.IsPrecursor(ionType);
CustomMolecule customIon = null;
if (isCustom)
{
if (measuredIon != null)
{
customIon = measuredIon.SettingsCustomIon;
}
else if (isPrecursor)
{
customIon = group.CustomMolecule;
}
else
{
var formula = DataValues.FromOptional(transitionProto.Formula);
var moleculeID = MoleculeAccessionNumbers.FromString(DataValues.FromOptional(transitionProto.MoleculeId)); // Tab separated list of InChiKey, CAS etc
var monoMassH = DataValues.FromOptional(transitionProto.MonoMassH);
var averageMassH = DataValues.FromOptional(transitionProto.AverageMassH);
var monoMass = DataValues.FromOptional(transitionProto.MonoMass) ?? monoMassH;
var averageMass = DataValues.FromOptional(transitionProto.AverageMass) ?? averageMassH;
customIon = new CustomMolecule(formula,
new TypedMass(monoMass.Value, monoMassH.HasValue ? MassType.MonoisotopicMassH : MassType.Monoisotopic),
new TypedMass(averageMass.Value, averageMassH.HasValue ? MassType.AverageMassH : MassType.Average),
DataValues.FromOptional(transitionProto.CustomIonName), moleculeID);
}
}
Transition transition;
var adductString = DataValues.FromOptional(transitionProto.Adduct);
var adduct = string.IsNullOrEmpty(adductString)
? Adduct.FromChargeProtonated(transitionProto.Charge)
: Adduct.FromStringAssumeChargeOnly(adductString);
if (isCustom)
{
transition = new Transition(group, isPrecursor ? group.PrecursorAdduct :adduct, transitionProto.MassIndex, customIon, ionType);
}
else if (isPrecursor)
{
transition = new Transition(group, ionType, group.Peptide.Length - 1, transitionProto.MassIndex,
group.PrecursorAdduct, DataValues.FromOptional(transitionProto.DecoyMassShift));
}
else
{
int offset = Transition.OrdinalToOffset(ionType, transitionProto.FragmentOrdinal,
group.Peptide.Length);
transition = new Transition(group, ionType, offset, transitionProto.MassIndex, adduct, DataValues.FromOptional(transitionProto.DecoyMassShift));
}
var losses = TransitionLosses.FromLossProtos(settings, transitionProto.Losses);
var mass = settings.GetFragmentMass(group, mods, transition, isotopeDist);
var isotopeDistInfo = GetIsotopeDistInfo(transition, losses, isotopeDist);
if (group.DecoyMassShift.HasValue && transitionProto.DecoyMassShift == null)
{
throw new InvalidDataException(Resources.SrmDocument_ReadTransitionXml_All_transitions_of_decoy_precursors_must_have_a_decoy_mass_shift);
}
TransitionLibInfo libInfo = null;
if (transitionProto.LibInfo != null)
{
libInfo = new TransitionLibInfo(transitionProto.LibInfo.Rank, transitionProto.LibInfo.Intensity);
}
var annotations = scrubber.ScrubAnnotations(Annotations.FromProtoAnnotations(transitionProto.Annotations), AnnotationDef.AnnotationTarget.transition);
var results = TransitionChromInfo.FromProtoTransitionResults(scrubber, settings, transitionProto.Results);
var explicitTransitionValues = pre422ExplicitTransitionValues ?? ExplicitTransitionValues.Create(
DataValues.FromOptional(transitionProto.ExplicitCollisionEnergy),
DataValues.FromOptional(transitionProto.ExplicitIonMobilityHighEnergyOffset),
DataValues.FromOptional(transitionProto.ExplicitSLens),
DataValues.FromOptional(transitionProto.ExplicitConeVoltage),
DataValues.FromOptional(transitionProto.ExplicitDeclusteringPotential));
return(new TransitionDocNode(transition, annotations, losses, mass, new TransitionQuantInfo(isotopeDistInfo, libInfo, !transitionProto.NotQuantitative), explicitTransitionValues, results));
}
public static OptimizationDb ConvertFromOldFormat(string path, IProgressMonitor loadMonitor, ProgressStatus status, SrmDocument document)
{
// Try to open assuming old format (Id, PeptideModSeq, Charge, Mz, Value, Type)
var precursors = new Dictionary <Target, HashSet <int> >(); // PeptideModSeq -> charges
var optimizations = new List <Tuple <DbOptimization, double> >(); // DbOptimization, product m/z
int maxCharge = 1;
using (SQLiteConnection connection = new SQLiteConnection(@"Data Source = " + path))
using (SQLiteCommand command = new SQLiteCommand(connection))
{
connection.Open();
command.CommandText = @"SELECT PeptideModSeq, Charge, Mz, Value, Type FROM OptimizationLibrary";
using (SQLiteDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
var type = (OptimizationType)reader[@"Type"];
var modifiedSequence = new Target(reader[@"PeptideModSeq"].ToString());
var charge = (int)reader[@"Charge"];
var productMz = (double)reader[@"Mz"];
var value = (double)reader[@"Value"];
optimizations.Add(new Tuple <DbOptimization, double>(new DbOptimization(type, modifiedSequence, Adduct.FromChargeProtonated(charge), string.Empty, Adduct.EMPTY, value), productMz));
if (!precursors.ContainsKey(modifiedSequence))
{
precursors[modifiedSequence] = new HashSet <int>();
}
precursors[modifiedSequence].Add(charge);
if (charge > maxCharge)
{
maxCharge = charge;
}
}
}
}
var peptideList = (from precursor in precursors
from charge in precursor.Value
select string.Format(@"{0}{1}", precursor.Key, Transition.GetChargeIndicator(Adduct.FromChargeProtonated(charge)))
).ToList();
var newDoc = new SrmDocument(document != null ? document.Settings : SrmSettingsList.GetDefault());
newDoc = newDoc.ChangeSettings(newDoc.Settings
.ChangePeptideLibraries(libs => libs.ChangePick(PeptidePick.filter))
.ChangeTransitionFilter(filter =>
filter.ChangeFragmentRangeFirstName(@"ion 1")
.ChangeFragmentRangeLastName(@"last ion")
.ChangePeptideProductCharges(Enumerable.Range(1, maxCharge).Select(Adduct.FromChargeProtonated).ToList()) // TODO(bspratt) negative charge peptides
.ChangePeptideIonTypes(new [] { IonType.y, IonType.b })) // TODO(bspratt) generalize to molecules?
.ChangeTransitionLibraries(libs => libs.ChangePick(TransitionLibraryPick.none))
);
var matcher = new ModificationMatcher();
matcher.CreateMatches(newDoc.Settings, peptideList, Settings.Default.StaticModList, Settings.Default.HeavyModList);
FastaImporter importer = new FastaImporter(newDoc, matcher);
// ReSharper disable LocalizableElement
string text = string.Format(">>{0}\r\n{1}", newDoc.GetPeptideGroupId(true), TextUtil.LineSeparate(peptideList));
// ReSharper restore LocalizableElement
PeptideGroupDocNode imported = importer.Import(new StringReader(text), null, Helpers.CountLinesInString(text)).First();
int optimizationsUpdated = 0;
foreach (PeptideDocNode nodePep in imported.Children)
{
foreach (var nodeGroup in nodePep.TransitionGroups)
{
var charge = nodeGroup.PrecursorAdduct;
var libKeyToMatch = newDoc.Settings.GetSourceTarget(nodePep).GetLibKey(charge).LibraryKey;
foreach (var nodeTran in nodeGroup.Transitions)
{
double productMz = nodeTran.Mz;
foreach (var optimization in optimizations.Where(opt =>
string.IsNullOrEmpty(opt.Item1.FragmentIon) &&
opt.Item1.ProductAdduct.IsEmpty &&
Math.Abs(opt.Item2 - productMz) < 0.00001))
{
var optLibKey = optimization.Item1.Target.GetLibKey(optimization.Item1.Adduct).LibraryKey;
if (!LibKeyIndex.KeysMatch(optLibKey, libKeyToMatch))
{
continue;
}
optimization.Item1.FragmentIon = nodeTran.FragmentIonName;
optimization.Item1.ProductAdduct = nodeTran.Transition.Adduct;
++optimizationsUpdated;
}
}
}
}
if (optimizations.Count > optimizationsUpdated)
{
throw new OptimizationsOpeningException(string.Format(Resources.OptimizationDb_ConvertFromOldFormat_Failed_to_convert__0__optimizations_to_new_format_,
optimizations.Count - optimizationsUpdated));
}
using (var fs = new FileSaver(path))
{
OptimizationDb db = CreateOptimizationDb(fs.SafeName);
db.UpdateOptimizations(optimizations.Select(opt => opt.Item1).ToArray(), new DbOptimization[0]);
fs.Commit();
if (loadMonitor != null)
{
loadMonitor.UpdateProgress(status.ChangePercentComplete(100));
}
return(GetOptimizationDb(fs.RealName, null, null));
}
}
/// <summary>
/// Test Skyline document sharing with libraries.
/// </summary>
protected override void DoTest()
{
// Open the .sky file
string documentPath = TestFilesDir.GetTestPath(DOCUMENT_NAME);
RunUI(() => SkylineWindow.OpenFile(documentPath));
// SCIEX parameter equations changed in 4.1.1
RunDlg <TransitionSettingsUI>(() => SkylineWindow.ShowTransitionSettingsUI(), tranSettings =>
{
tranSettings.RegressionCEName = "SCIEX";
tranSettings.RegressionDPName = "SCIEX";
tranSettings.OkDialog();
});
// Delete the last protein because its peptide has an explicit modification
// which just gets in the way for this test.
SelectNode(SrmDocument.Level.MoleculeGroups, SkylineWindow.Document.PeptideGroupCount - 1);
RunUI(SkylineWindow.EditDelete);
// Select the first precursor and inspect its graph
SelectNode(SrmDocument.Level.TransitionGroups, 0);
WaitForLibraries();
WaitForGraphs();
int ionCount = 0;
RunUI(() => ionCount = SkylineWindow.GraphSpectrum.PeaksMatchedCount);
RunUI(() => SkylineWindow.GraphSpectrumSettings.ShowPrecursorIon = true);
WaitForGraphs();
RunUI(() => Assert.AreEqual(ionCount + 1, SkylineWindow.GraphSpectrum.PeaksMatchedCount));
string precursorPrefix = IonType.precursor.GetLocalizedString();
string precursorLabel = precursorPrefix + Transition.GetChargeIndicator(Adduct.FromChargeProtonated(2));
SrmDocument docCurrent = SkylineWindow.Document;
var pickList0 = ShowDialog <PopupPickList>(SkylineWindow.ShowPickChildrenInTest);
RunUI(() =>
{
Assert.IsFalse(pickList0.ItemNames.Contains(name => name.StartsWith(precursorPrefix)));
pickList0.ApplyFilter(false);
Assert.IsTrue(pickList0.ItemNames.Contains(name => name.StartsWith(precursorPrefix)));
pickList0.ToggleFind();
pickList0.SearchString = precursorPrefix;
pickList0.SetItemChecked(0, true);
pickList0.OnOk();
});
WaitForDocumentChange(docCurrent);
docCurrent = SkylineWindow.Document;
Assert.AreEqual(IonType.precursor, new List <TransitionDocNode>(docCurrent.PeptideTransitions)[0].Transition.IonType,
"First transition is not precursor type.");
SelectNode(SrmDocument.Level.Transitions, 0);
VerifySelectedIon(precursorLabel);
SelectNode(SrmDocument.Level.TransitionGroups, 2); // Charge 3
docCurrent = SkylineWindow.Document;
var pickList1 = ShowDialog <PopupPickList>(SkylineWindow.ShowPickChildrenInTest);
RunUI(() =>
{
pickList1.ApplyFilter(false);
pickList1.SetItemChecked(0, true);
pickList1.OnOk();
});
WaitForDocumentChange(docCurrent);
RunUI(() => SkylineWindow.SaveDocument());
RunUI(SkylineWindow.NewDocument);
RunUI(() => SkylineWindow.OpenFile(documentPath));
Assert.AreEqual(2, GetPrecursorTranstionCount());
// Export a transition list
string tranListPath = TestFilesDir.GetTestPath("TransitionList.csv");
var exportDialog = ShowDialog <ExportMethodDlg>(() => SkylineWindow.ShowExportMethodDialog(ExportFileType.List));
RunUI(() =>
{
exportDialog.ExportStrategy = ExportStrategy.Single;
exportDialog.MethodType = ExportMethodType.Standard;
exportDialog.OkDialog(tranListPath);
});
WaitForCondition(() => File.Exists(tranListPath));
// Save a copy of the current document
docCurrent = SkylineWindow.Document;
// Delete remaining 2 proteins
SelectNode(SrmDocument.Level.MoleculeGroups, 0);
RunUI(() =>
{
SkylineWindow.EditDelete();
SkylineWindow.EditDelete();
});
// Paste the transition list
SetClipboardTextUI(File.ReadAllText(tranListPath));
RunUI(() => SkylineWindow.Paste());
Assert.AreEqual(2, GetPrecursorTranstionCount());
Assert.AreEqual(docCurrent.PeptideTransitionCount, SkylineWindow.Document.PeptideTransitionCount);
Assert.AreEqual(IonType.precursor, new List <TransitionDocNode>(docCurrent.PeptideTransitions)[0].Transition.IonType,
"First transition is not precursor type.");
SelectNode(SrmDocument.Level.Transitions, 0);
VerifySelectedIon(precursorLabel);
}
private static void TestEditingTransitionGroup()
{
RunUI(() =>
{
// Select the first precursor
SkylineWindow.SequenceTree.SelectedNode = SkylineWindow.SequenceTree.Nodes[0].FirstNode.Nodes[0];
});
var docA = SkylineWindow.Document;
var editMoleculeDlgA = ShowDialog <EditCustomMoleculeDlg>(SkylineWindow.ModifySmallMoleculeTransitionGroup);
RunUI(() =>
{
// Test the "set" part of "Issue 371: Small molecules: need to be able to import and/or set CE, RT and DT for individual precursors and products"
editMoleculeDlgA.IonMobility = TESTVALUES.IonMobility.Value;
editMoleculeDlgA.IonMobilityHighEnergyOffset = TESTVALUES.IonMobilityHighEnergyOffset.Value;
editMoleculeDlgA.IonMobilityUnits = TESTVALUES.IonMobilityUnits;
editMoleculeDlgA.CollisionalCrossSectionSqA = TESTVALUES.CollisionalCrossSectionSqA.Value;
editMoleculeDlgA.CollisionEnergy = TESTVALUES.CollisionEnergy.Value;
editMoleculeDlgA.SLens = TESTVALUES.SLens.Value;
editMoleculeDlgA.ConeVoltage = TESTVALUES.ConeVoltage;
editMoleculeDlgA.DeclusteringPotential = TESTVALUES.DeclusteringPotential;
editMoleculeDlgA.CompensationVoltage = TESTVALUES.CompensationVoltage;
});
OkDialog(editMoleculeDlgA, editMoleculeDlgA.OkDialog);
var doc = WaitForDocumentChange(docA);
var peptideDocNode = doc.Molecules.ElementAt(0);
Assert.IsNotNull(peptideDocNode);
Assert.IsTrue(peptideDocNode.EqualsId(docA.Molecules.ElementAt(0))); // No Id change
Assert.IsTrue(doc.MoleculeTransitionGroups.ElementAt(0).EqualsId(docA.MoleculeTransitionGroups.ElementAt(0))); // No change to Id node or its child Ids
Assert.AreEqual(TESTVALUES, doc.MoleculeTransitionGroups.ElementAt(0).ExplicitValues);
Assert.IsNull(peptideDocNode.ExplicitRetentionTime);
var editMoleculeDlg = ShowDialog <EditCustomMoleculeDlg>(SkylineWindow.ModifySmallMoleculeTransitionGroup);
double massPrecisionTolerance = Math.Pow(10, -SequenceMassCalc.MassPrecision);
double massAverage = 0;
double massMono = 0;
RunUI(() =>
{
Assert.AreEqual(COOO13H, editMoleculeDlg.NameText); // Comes from the docnode
Assert.AreEqual(COOO13H, editMoleculeDlg.FormulaBox.NeutralFormula); // Comes from the docnode
Assert.AreEqual(COOO13H + "[M+H]", editMoleculeDlg.FormulaBox.Formula); // Comes from the docnode
Assert.AreEqual(BioMassCalc.MONOISOTOPIC.CalculateMassFromFormula(COOO13H), editMoleculeDlg.FormulaBox.MonoMass ?? -1, massPrecisionTolerance);
Assert.AreEqual(BioMassCalc.AVERAGE.CalculateMassFromFormula(COOO13H), editMoleculeDlg.FormulaBox.AverageMass ?? -1, massPrecisionTolerance);
// Now try something crazy
editMoleculeDlg.FormulaBox.Formula = "[M+500H]";
});
// Trying to exit the dialog should cause a warning about charge state
RunDlg <MessageDlg>(editMoleculeDlg.OkDialog, dlg =>
{
AssertEx.AreComparableStrings(
string.Format(Resources.MessageBoxHelper_ValidateSignedNumberTextBox_Value__0__must_be_between__1__and__2__or__3__and__4__,
500,
-TransitionGroup.MAX_PRECURSOR_CHARGE,
-TransitionGroup.MIN_PRECURSOR_CHARGE,
TransitionGroup.MIN_PRECURSOR_CHARGE,
TransitionGroup.MAX_PRECURSOR_CHARGE),
dlg.Message);
dlg.OkDialog(); // Dismiss the warning
});
RunUI(() =>
{
editMoleculeDlg.FormulaBox.Formula = "[M+H]";
});
// Test charge state limits
RunUI(() => editMoleculeDlg.Adduct = Adduct.FromChargeProtonated(TransitionGroup.MAX_PRECURSOR_CHARGE + 1));
RunDlg <MessageDlg>(editMoleculeDlg.OkDialog, dlg =>
{
// Trying to exit the dialog should cause a warning about charge
Assert.AreEqual(
String.Format(Resources.MessageBoxHelper_ValidateSignedNumberTextBox_Value__0__must_be_between__1__and__2__or__3__and__4__,
TransitionGroup.MAX_PRECURSOR_CHARGE + 1,
-TransitionGroup.MAX_PRECURSOR_CHARGE,
-TransitionGroup.MIN_PRECURSOR_CHARGE,
TransitionGroup.MIN_PRECURSOR_CHARGE,
TransitionGroup.MAX_PRECURSOR_CHARGE), dlg.Message);
dlg.OkDialog(); // Dismiss the warning
});
RunUI(() => editMoleculeDlg.Adduct = Adduct.FromChargeProtonated(-(TransitionGroup.MAX_PRECURSOR_CHARGE + 1)));
RunDlg <MessageDlg>(editMoleculeDlg.OkDialog, dlg =>
{
// Trying to exit the dialog should cause a warning about charge
Assert.AreEqual(
String.Format(Resources.MessageBoxHelper_ValidateSignedNumberTextBox_Value__0__must_be_between__1__and__2__or__3__and__4__,
-(TransitionGroup.MAX_PRECURSOR_CHARGE + 1),
-TransitionGroup.MAX_PRECURSOR_CHARGE,
-TransitionGroup.MIN_PRECURSOR_CHARGE,
TransitionGroup.MIN_PRECURSOR_CHARGE,
TransitionGroup.MAX_PRECURSOR_CHARGE), dlg.Message);
dlg.OkDialog(); // Dismiss the warning
});
// Restore
RunUI(() =>
{
Assert.AreEqual(2.115335, double.Parse(editMoleculeDlg.FormulaBox.MonoText), .0001);
Assert.AreEqual(2.116302, double.Parse(editMoleculeDlg.FormulaBox.AverageText), .0001);
editMoleculeDlg.Adduct = Adduct.NonProteomicProtonatedFromCharge(2); // Back to sanity
massAverage = editMoleculeDlg.FormulaBox.AverageMass.Value;
massMono = editMoleculeDlg.FormulaBox.MonoMass.Value;
Assert.AreEqual(BioMassCalc.AVERAGE.CalculateMassFromFormula(COOO13H), massAverage, massPrecisionTolerance);
Assert.AreEqual(BioMassCalc.MONOISOTOPIC.CalculateMassFromFormula(COOO13H), massMono, massPrecisionTolerance);
Assert.AreEqual(.5 * massMono + AminoAcidFormulas.ProtonMass, double.Parse(editMoleculeDlg.FormulaBox.MonoText), .001);
Assert.AreEqual(.5 * massAverage + AminoAcidFormulas.ProtonMass, double.Parse(editMoleculeDlg.FormulaBox.AverageText), .001);
});
OkDialog(editMoleculeDlg, editMoleculeDlg.OkDialog);
var newdoc = WaitForDocumentChange(doc);
Assert.AreEqual(massAverage, newdoc.MoleculeTransitionGroups.ElementAt(0).CustomMolecule.AverageMass, massPrecisionTolerance);
Assert.AreEqual(massMono, newdoc.MoleculeTransitionGroups.ElementAt(0).CustomMolecule.MonoisotopicMass, massPrecisionTolerance);
Assert.IsNotNull(newdoc.Molecules.ElementAt(0).CustomMolecule.Formula); // Molecule and children share base molecule
Assert.AreEqual(.5 * massMono + BioMassCalc.MassProton, newdoc.MoleculeTransitionGroups.ElementAt(0).PrecursorMz, .001);
Assert.IsFalse(newdoc.MoleculeTransitionGroups.ElementAt(0).EqualsId(peptideDocNode)); // Changing the adduct changes the Id node
// Verify that CE overrides work
Assert.AreEqual(TESTVALUES, newdoc.MoleculeTransitionGroups.ElementAt(0).ExplicitValues);
Assert.IsNull(newdoc.Molecules.ElementAt(0).ExplicitRetentionTime); // Not set yet
// Verify that the explicitly set drift time overides any calculations
double windowDT;
double driftTimeMax = 1000.0;
var centerDriftTime = newdoc.Settings.PeptideSettings.Prediction.GetIonMobility(
newdoc.Molecules.First(), newdoc.MoleculeTransitionGroups.First(), null, null, driftTimeMax, out windowDT);
Assert.AreEqual(TESTVALUES.IonMobility.Value, centerDriftTime.IonMobility.Mobility.Value, .0001);
Assert.AreEqual(TESTVALUES.IonMobility.Value + TESTVALUES.IonMobilityHighEnergyOffset.Value, centerDriftTime.GetHighEnergyDriftTimeMsec() ?? 0, .0001);
Assert.AreEqual(0, windowDT, .0001);
// Verify that tree selection doesn't change just because we changed an ID object
// (formerly the tree node would collapse and focus would jump up a level)
RunUI(() =>
{
Assert.AreEqual(SkylineWindow.SequenceTree.SelectedNode, SkylineWindow.SequenceTree.Nodes[0].FirstNode);
});
}
private static void TestAddingSmallMolecule()
{
RunUI(() => SkylineWindow.SelectedPath = new IdentityPath(SkylineWindow.Document.MoleculeGroups.ElementAt(0).Id));
var doc = SkylineWindow.Document;
var editMoleculeDlg = ShowDialog <EditCustomMoleculeDlg>(SkylineWindow.AddSmallMolecule);
// Less extreme values should trigger a warning about instrument limits
RunUI(() =>
{
editMoleculeDlg.FormulaBox.MonoMass = CustomMolecule.MAX_MASS - 100;
editMoleculeDlg.FormulaBox.AverageMass = editMoleculeDlg.FormulaBox.MonoMass;
});
RunDlg <MessageDlg>(editMoleculeDlg.OkDialog, dlg =>
{
AssertEx.AreComparableStrings(
Resources
.SkylineWindow_AddMolecule_The_precursor_m_z_for_this_molecule_is_out_of_range_for_your_instrument_settings_,
dlg.Message);
dlg.OkDialog(); // Dismiss the warning
});
RunUI(() =>
{
// Verify the interaction of explicitly set formula, mz and charge
editMoleculeDlg.FormulaBox.Formula = C12H12;
var mono = editMoleculeDlg.FormulaBox.MonoMass ?? -1;
var average = editMoleculeDlg.FormulaBox.AverageMass ?? -1;
var massPrecisionTolerance = Math.Pow(10, -SequenceMassCalc.MassPrecision);
Assert.AreEqual(BioMassCalc.MONOISOTOPIC.CalculateMassFromFormula(C12H12), mono, massPrecisionTolerance);
Assert.AreEqual(BioMassCalc.AVERAGE.CalculateMassFromFormula(C12H12), average, massPrecisionTolerance);
Assert.AreEqual(mono, double.Parse(editMoleculeDlg.FormulaBox.MonoText), massPrecisionTolerance);
Assert.AreEqual(average, double.Parse(editMoleculeDlg.FormulaBox.AverageText), massPrecisionTolerance);
editMoleculeDlg.Adduct = Adduct.NonProteomicProtonatedFromCharge(3);
Assert.AreEqual(
Math.Round(BioMassCalc.MONOISOTOPIC.CalculateMassFromFormula(C12H12), SequenceMassCalc.MassPrecision),
mono); // Masses should not change
Assert.AreEqual(
Math.Round(BioMassCalc.AVERAGE.CalculateMassFromFormula(C12H12), SequenceMassCalc.MassPrecision),
average);
editMoleculeDlg.Adduct = Adduct.FromChargeProtonated(1);
Assert.AreEqual(
Math.Round(BioMassCalc.MONOISOTOPIC.CalculateMassFromFormula(C12H12), SequenceMassCalc.MassPrecision),
mono); // Masses should not change
Assert.AreEqual(
Math.Round(BioMassCalc.AVERAGE.CalculateMassFromFormula(C12H12), SequenceMassCalc.MassPrecision),
average);
Assert.AreEqual(BioMassCalc.MONOISOTOPIC.CalculateIonMz(C12H12, editMoleculeDlg.Adduct),
mono + BioMassCalc.MassProton,
massPrecisionTolerance);
Assert.AreEqual(BioMassCalc.AVERAGE.CalculateIonMz(C12H12, editMoleculeDlg.Adduct),
average + BioMassCalc.MassProton,
massPrecisionTolerance);
editMoleculeDlg.Adduct = Adduct.NonProteomicProtonatedFromCharge(-1); // Validate negative charges
Assert.AreEqual(
Math.Round(BioMassCalc.MONOISOTOPIC.CalculateMassFromFormula(C12H12), SequenceMassCalc.MassPrecision),
mono); // Masses should not change
Assert.AreEqual(
Math.Round(BioMassCalc.AVERAGE.CalculateMassFromFormula(C12H12), SequenceMassCalc.MassPrecision),
average);
Assert.AreEqual(BioMassCalc.MONOISOTOPIC.CalculateIonMz(C12H12, editMoleculeDlg.Adduct),
mono - BioMassCalc.MassProton,
massPrecisionTolerance);
Assert.AreEqual(BioMassCalc.AVERAGE.CalculateIonMz(C12H12, editMoleculeDlg.Adduct),
average - BioMassCalc.MassProton,
massPrecisionTolerance);
editMoleculeDlg.FormulaBox.Formula = string.Empty; // Simulate user blanking out the formula
Assert.AreEqual(mono, editMoleculeDlg.FormulaBox.MonoMass); // Leaves masses untouched
Assert.AreEqual(average, editMoleculeDlg.FormulaBox.AverageMass);
editMoleculeDlg.FormulaBox.AverageMass = averageMass100;
editMoleculeDlg.FormulaBox.MonoMass = monoMass105;
editMoleculeDlg.NameText = "test";
Assert.IsTrue(string.IsNullOrEmpty(editMoleculeDlg.FormulaBox.Formula));
Assert.AreEqual(averageMass100, editMoleculeDlg.FormulaBox.AverageMass);
Assert.AreEqual(monoMass105, editMoleculeDlg.FormulaBox.MonoMass);
var monoMzText = editMoleculeDlg.FormulaBox.MonoText;
var averageMzText = editMoleculeDlg.FormulaBox.AverageText;
var mzMonoAtMminusH = double.Parse(monoMzText);
var mzAverageAtMminusH = double.Parse(averageMzText);
editMoleculeDlg.Adduct = Adduct.NonProteomicProtonatedFromCharge(3);
Assert.AreEqual(monoMzText, editMoleculeDlg.FormulaBox.MonoText); // m/z readout should not change
Assert.AreEqual(averageMzText, editMoleculeDlg.FormulaBox.AverageText);
// If this mz is now said to be due to higher charge, then mass must greater
Assert.AreEqual(3 * (mzAverageAtMminusH - BioMassCalc.MassProton),
editMoleculeDlg.FormulaBox.AverageMass.Value, massPrecisionTolerance);
Assert.AreEqual(3 * (mzMonoAtMminusH - BioMassCalc.MassProton),
editMoleculeDlg.FormulaBox.MonoMass.Value, massPrecisionTolerance);
// If this mz is now said to be due to lesser z, then mass must smaller
editMoleculeDlg.Adduct = Adduct.NonProteomicProtonatedFromCharge(1);
Assert.AreEqual(monoMzText, editMoleculeDlg.FormulaBox.MonoText); // m/z readout should not change
Assert.AreEqual(averageMzText, editMoleculeDlg.FormulaBox.AverageText);
var massAverage = editMoleculeDlg.FormulaBox.AverageMass.Value;
var massMono = editMoleculeDlg.FormulaBox.MonoMass.Value;
Assert.AreEqual(averageMass100 - BioMassCalc.MassProton, massAverage, massPrecisionTolerance); // Mass should change back
Assert.AreEqual(monoMass105 - BioMassCalc.MassProton, massMono, massPrecisionTolerance);
});
var adduct = Adduct.NonProteomicProtonatedFromCharge(1);
RunUI(() =>
{
editMoleculeDlg.NameText = COOO13H;
editMoleculeDlg.FormulaBox.Formula = COOO13H + adduct.AdductFormula;
});
OkDialog(editMoleculeDlg, editMoleculeDlg.OkDialog);
var compareIon = new CustomMolecule(COOO13H, COOO13H);
var newDoc = WaitForDocumentChange(doc);
Assert.AreEqual(compareIon, newDoc.Molecules.ElementAt(0).CustomMolecule);
Assert.AreEqual(compareIon, newDoc.MoleculeTransitionGroups.ElementAt(0).CustomMolecule);
Assert.AreEqual(adduct.AdductCharge, newDoc.MoleculeTransitionGroups.ElementAt(0).PrecursorCharge);
var predictedMz = BioMassCalc.MONOISOTOPIC.CalculateIonMz(COOO13H, adduct);
var actualMz = newDoc.MoleculeTransitionGroups.ElementAt(0).PrecursorMz;
Assert.AreEqual(predictedMz, actualMz, Math.Pow(10, -SequenceMassCalc.MassPrecision));
}
private static string GetTransitionName(XmlTransition transition)
{
return(AbiMassListExporter.GetTransitionName(Adduct.FromChargeProtonated(transition.PrecursorCharge),
transition.FragmentType.ToString().ToLower() + transition.FragmentOrdinal,
Adduct.FromChargeProtonated(transition.ProductCharge)));
}
private void TestAddingSmallMoleculePrecursor()
{
// Position ourselves on the first molecule
var newDoc = SkylineWindow.Document;
SelectNode(SrmDocument.Level.Molecules, 0);
var moleculeDlg = ShowDialog <EditCustomMoleculeDlg>(SkylineWindow.AddSmallMolecule);
var adduct = moleculeDlg.FormulaBox.Adduct.ChangeIsotopeLabels(new Dictionary <string, int> {
{ "O'", 1 }
}); // Not L10N
RunUI(() =>
{
moleculeDlg.IsotopeLabelType = IsotopeLabelType.light; // This should provoke a failure - can't have two of the same label and charge
});
RunDlg <MessageDlg>(moleculeDlg.OkDialog, dlg =>
{
// Trying to exit the dialog should cause a warning about adduct and label conflict
Assert.AreEqual(Resources.EditCustomMoleculeDlg_OkDialog_A_precursor_with_that_adduct_and_label_type_already_exists_, dlg.Message);
dlg.OkDialog(); // Dismiss the warning
});
RunUI(() =>
{
moleculeDlg.FormulaBox.Adduct = adduct;
moleculeDlg.IsotopeLabelType = IsotopeLabelType.heavy;
});
OkDialog(moleculeDlg, moleculeDlg.OkDialog);
newDoc = WaitForDocumentChange(newDoc);
Assert.AreEqual(adduct, newDoc.MoleculeTransitionGroups.ElementAt(1).TransitionGroup.PrecursorAdduct);
var predictedMz = BioMassCalc.MONOISOTOPIC.CalculateIonMz(COOO13H, adduct);
var actualMz = newDoc.MoleculeTransitionGroups.ElementAt(1).PrecursorMz;
Assert.AreEqual(predictedMz, actualMz, Math.Pow(10, -SequenceMassCalc.MassPrecision));
// Now verify that we are OK with different charge same label
SelectNode(SrmDocument.Level.Molecules, 0);
var moleculeDlg2 = ShowDialog <EditCustomMoleculeDlg>(SkylineWindow.AddSmallMolecule);
RunUI(() =>
{
moleculeDlg2.Adduct = Adduct.FromChargeProtonated(adduct.AdductCharge + 1);
moleculeDlg2.IsotopeLabelType = IsotopeLabelType.light; // This should not provoke a failure
});
OkDialog(moleculeDlg2, moleculeDlg2.OkDialog);
// Verify that the transition group sort order is enforced in the document
// Select the last precursor, bump its charge state to drop its mz - should result in doc node reordering
CheckTransitionGroupSortOrder(newDoc);
RunUI(() =>
{
SkylineWindow.SequenceTree.SelectedNode = SkylineWindow.SequenceTree.Nodes[0].FirstNode.LastNode;
});
var editMoleculeDlgB = ShowDialog <EditCustomMoleculeDlg>(SkylineWindow.ModifySmallMoleculeTransitionGroup);
RunUI(() =>
{
editMoleculeDlgB.Adduct = Adduct.NonProteomicProtonatedFromCharge(5);
});
OkDialog(editMoleculeDlgB, editMoleculeDlgB.OkDialog);
newDoc = WaitForDocumentChange(newDoc);
CheckTransitionGroupSortOrder(newDoc);
RunUI(SkylineWindow.Undo);
newDoc = WaitForDocumentChange(newDoc);
CheckTransitionGroupSortOrder(newDoc);
}
public IEnumerable <TransitionGroup> GetTransitionGroups(SrmSettings settings, PeptideDocNode nodePep, ExplicitMods mods, bool useFilter)
{
if (IsCustomMolecule)
{
// TODO(bspratt) WHY NOT USING TRANSITION SETTINGS FILTER PRECURSOR ADDUCTS?
// We can't generate precursors as we do with peptides, so just filter what we do have on instrument mz range
//var precursorAdducts = settings.TransitionSettings.Filter.SmallMoleculePrecursorAdducts;
// TODO(bspratt) generate precursor transitions if doc has no fragments
// CONSIDER(bspratt) could we reasonably reuse fragments with proposed precursors of suitable charge and polarity (say, add an M+Na node that mimics an existing M+H node and children)
foreach (var group in nodePep.TransitionGroups.Where(tranGroup => tranGroup.TransitionGroup.IsCustomIon))
{
if (!useFilter || settings.TransitionSettings.IsMeasurablePrecursor(group.PrecursorMz))
{
yield return(group.TransitionGroup);
}
}
}
else
{
var precursorCharges = settings.TransitionSettings.Filter.PeptidePrecursorCharges;
if (!useFilter)
{
precursorCharges = new List <Adduct>();
for (int i = TransitionGroup.MIN_PRECURSOR_CHARGE; i < TransitionGroup.MAX_PRECURSOR_CHARGE; i++)
{
precursorCharges.Add(Adduct.FromChargeProtonated(i));
}
}
var modSettings = settings.PeptideSettings.Modifications;
var precursorMassLight = settings.GetPrecursorMass(IsotopeLabelType.light, Target, mods);
var listPrecursorMasses = new List <KeyValuePair <IsotopeLabelType, TypedMass> >
{
new KeyValuePair <IsotopeLabelType, TypedMass>(IsotopeLabelType.light, precursorMassLight)
};
foreach (var typeMods in modSettings.GetHeavyModifications())
{
IsotopeLabelType labelType = typeMods.LabelType;
var precursorMass = precursorMassLight;
if (settings.HasPrecursorCalc(labelType, mods))
{
precursorMass = settings.GetPrecursorMass(labelType, Target, mods);
}
listPrecursorMasses.Add(new KeyValuePair <IsotopeLabelType, TypedMass>(labelType, precursorMass));
}
foreach (var adduct in precursorCharges)
{
if (useFilter && !settings.Accept(settings, this, mods, adduct))
{
continue;
}
for (int i = 0; i < listPrecursorMasses.Count; i++)
{
var pair = listPrecursorMasses[i];
IsotopeLabelType labelType = pair.Key;
var precursorMass = pair.Value;
// Only return a heavy group, if the precursor masses differ
// between the light and heavy calculators
if (i == 0 || precursorMass != precursorMassLight)
{
if (settings.TransitionSettings.IsMeasurablePrecursor(SequenceMassCalc.GetMZ(precursorMass, adduct)))
{
yield return(new TransitionGroup(this, adduct, labelType));
}
}
}
}
}
}
