private void GetSmallMoleculeFragments(LibKey key, TransitionGroupDocNode nodeGroupMatched, SpectrumPeaksInfo spectrum,
IList <DocNode> transitionDocNodes)
{
// We usually don't know actual charge of fragments in the library, so just note + or - if
// there are no peak annotations containing that info
var fragmentCharge = key.Adduct.AdductCharge < 0 ? Adduct.M_MINUS : Adduct.M_PLUS;
// Get list of possible transitions based on library spectrum
var transitionsUnranked = new List <DocNode>();
foreach (var peak in spectrum.Peaks)
{
transitionsUnranked.Add(TransitionFromPeakAndAnnotations(key, nodeGroupMatched, fragmentCharge, peak, null));
}
var nodeGroupUnranked = (TransitionGroupDocNode)nodeGroupMatched.ChangeChildren(transitionsUnranked);
// Filter again, retain only those with rank info, or at least an interesting name
SpectrumHeaderInfo groupLibInfo = null;
var transitionRanks = new Dictionary <double, LibraryRankedSpectrumInfo.RankedMI>();
nodeGroupUnranked.GetLibraryInfo(Settings, ExplicitMods.EMPTY, true, ref groupLibInfo, transitionRanks);
foreach (var ranked in transitionRanks)
{
transitionDocNodes.Add(TransitionFromPeakAndAnnotations(key, nodeGroupMatched, fragmentCharge, ranked.Value.MI, ranked.Value.Rank));
}
// And add any unranked that have names to display
foreach (var unrankedT in nodeGroupUnranked.Transitions)
{
var unranked = unrankedT;
if (!string.IsNullOrEmpty(unranked.Transition.CustomIon.Name) &&
!transitionDocNodes.Any(t => t is TransitionDocNode && unranked.Transition.Equivalent(((TransitionDocNode)t).Transition)))
{
transitionDocNodes.Add(unranked);
}
}
}
public PeptideMatch(PeptideDocNode nodePep, IEnumerable <ProteinInfo> proteins, SpectrumHeaderInfo libInfo, bool matchesFilterSettings) : this()
{
NodePep = nodePep;
Proteins = proteins == null ? null : proteins.ToList();
MatchesFilterSettings = matchesFilterSettings;
LibInfo = libInfo;
}
public void GetLibraryInfo(SrmSettings settings, ExplicitMods mods, bool useFilter,
ref SpectrumHeaderInfo libInfo,
Dictionary <double, LibraryRankedSpectrumInfo.RankedMI> transitionRanks)
{
PeptideLibraries libraries = settings.PeptideSettings.Libraries;
// No libraries means no library info
if (!libraries.HasLibraries)
{
libInfo = null;
return;
}
// If not loaded, leave everything alone, and let the update
// when loading is complete fix things.
if (!libraries.IsLoaded)
{
return;
}
IsotopeLabelType labelType;
if (!settings.TryGetLibInfo(Peptide.Sequence, PrecursorCharge, mods, out labelType, out libInfo))
{
libInfo = null;
}
else if (transitionRanks != null)
{
try
{
SpectrumPeaksInfo spectrumInfo;
string sequenceMod = settings.GetModifiedSequence(Peptide.Sequence, labelType, mods);
if (libraries.TryLoadSpectrum(new LibKey(sequenceMod, PrecursorCharge), out spectrumInfo))
{
var spectrumInfoR = new LibraryRankedSpectrumInfo(spectrumInfo, labelType,
this, settings, mods, useFilter, 50);
foreach (var rmi in spectrumInfoR.PeaksRanked)
{
if (!transitionRanks.ContainsKey(rmi.PredictedMz))
{
transitionRanks.Add(rmi.PredictedMz, rmi);
}
if (!useFilter && rmi.PredictedMz2 != 0 && !transitionRanks.ContainsKey(rmi.PredictedMz2))
{
transitionRanks.Add(rmi.PredictedMz2, rmi);
}
}
}
}
// Catch and ignore file access exceptions
catch (IOException) {}
catch (UnauthorizedAccessException) {}
catch (ObjectDisposedException) {}
}
}
public override bool TryGetLibInfo(LibKey key, out SpectrumHeaderInfo libInfo)
{
BiblioSpectrumInfo info;
if (_dictLibrary != null && _dictLibrary.TryGetValue(key, out info))
{
libInfo = new BiblioSpecSpectrumHeaderInfo(Name, info.Copies);
return(true);
}
libInfo = null;
return(false);
}
public override bool TryGetLibInfo(LibKey key, out SpectrumHeaderInfo libInfo)
{
if (_dictLibrary != null)
{
foreach (var item in _dictLibrary.ItemsMatching(key.LibraryKey, true))
{
libInfo = new BiblioSpecSpectrumHeaderInfo(Name, item.Copies);
return(true);
}
}
libInfo = null;
return(false);
}
public static IList <DocNode> GetChoices(TransitionGroupDocNode nodeGroup, SrmSettings settings, ExplicitMods mods, bool useFilter)
{
TransitionGroup group = nodeGroup.TransitionGroup;
SpectrumHeaderInfo libInfo = null;
var transitionRanks = new Dictionary <double, LibraryRankedSpectrumInfo.RankedMI>();
group.GetLibraryInfo(settings, mods, useFilter, ref libInfo, transitionRanks);
var listChoices = new List <DocNode>();
foreach (TransitionDocNode nodeTran in nodeGroup.GetTransitions(settings, mods,
nodeGroup.PrecursorMz, nodeGroup.IsotopeDist, libInfo, transitionRanks, useFilter))
{
listChoices.Add(nodeTran);
}
return(listChoices);
}
public bool TryGetLibInfo(string sequence, int charge, ExplicitMods mods,
out IsotopeLabelType type, out SpectrumHeaderInfo libInfo)
{
if (sequence == null)
{
type = null;
libInfo = null;
return false;
}
var libraries = PeptideSettings.Libraries;
foreach (var typedSequence in GetTypedSequences(sequence, mods))
{
var key = new LibKey(typedSequence.ModifiedSequence, charge);
if (libraries.TryGetLibInfo(key, out libInfo))
{
type = typedSequence.LabelType;
return true;
}
}
type = IsotopeLabelType.light;
libInfo = null;
return false;
}
public override bool TryGetLibInfo(LibKey key, out SpectrumHeaderInfo libInfo)
{
libInfo = Contains(key) ? new BiblioSpecSpectrumHeaderInfo(Name, 1, null, null) : null;
return(libInfo != null);
}
public IEnumerable <TransitionDocNode> GetTransitions(SrmSettings settings,
TransitionGroupDocNode groupDocNode,
ExplicitMods mods,
double precursorMz,
IsotopeDistInfo isotopeDist,
SpectrumHeaderInfo libInfo,
IDictionary <double, LibraryRankedSpectrumInfo.RankedMI> transitionRanks,
bool useFilter)
{
Assume.IsTrue(ReferenceEquals(groupDocNode.TransitionGroup, this));
// Get necessary mass calculators and masses
var calcFilterPre = settings.GetPrecursorCalc(IsotopeLabelType.light, mods);
var calcFilter = settings.GetFragmentCalc(IsotopeLabelType.light, mods);
var calcPredict = settings.GetFragmentCalc(LabelType, mods);
string sequence = Peptide.Sequence;
// Save the true precursor m/z for TranstionSettings.Accept() now that all isotope types are
// checked. This is more correct than just using the light precursor m/z for precursor window
// exclusion.
double precursorMzAccept = precursorMz;
if (!ReferenceEquals(calcFilter, calcPredict))
{
// Get the normal precursor m/z for filtering, so that light and heavy ion picks will match.
precursorMz = IsCustomIon ?
BioMassCalc.CalculateIonMz(calcFilterPre.GetPrecursorMass(groupDocNode.CustomIon), groupDocNode.TransitionGroup.PrecursorCharge) :
SequenceMassCalc.GetMZ(calcFilterPre.GetPrecursorMass(sequence), groupDocNode.TransitionGroup.PrecursorCharge);
}
if (!IsAvoidMismatchedIsotopeTransitions)
{
precursorMzAccept = precursorMz;
}
var tranSettings = settings.TransitionSettings;
var filter = tranSettings.Filter;
var charges = filter.ProductCharges;
var startFinder = filter.FragmentRangeFirst;
var endFinder = filter.FragmentRangeLast;
double precursorMzWindow = filter.PrecursorMzWindow;
var types = filter.IonTypes;
MassType massType = tranSettings.Prediction.FragmentMassType;
int minMz = tranSettings.Instrument.GetMinMz(precursorMzAccept);
int maxMz = tranSettings.Instrument.MaxMz;
var pepMods = settings.PeptideSettings.Modifications;
var potentialLosses = CalcPotentialLosses(sequence, pepMods, mods, massType);
// A start m/z will need to be calculated if the start fragment
// finder uses m/z and their are losses to consider. If the filter
// is set to only consider fragments with m/z greater than the
// precursor, the code below needs to also prevent loss fragments
// from being under that m/z.
double startMz = 0;
// Get library settings
var pick = tranSettings.Libraries.Pick;
if (!useFilter)
{
pick = TransitionLibraryPick.all;
var listAll = Transition.ALL_CHARGES.ToList();
listAll.AddRange(charges.Where(c => !Transition.ALL_CHARGES.Contains(c)));
listAll.Sort();
charges = listAll.ToArray();
types = Transition.ALL_TYPES;
}
// If there are no libraries or no library information, then
// picking cannot use library information
else if (!settings.PeptideSettings.Libraries.HasLibraries || libInfo == null)
{
pick = TransitionLibraryPick.none;
}
// If filtering without library picking
if (potentialLosses != null)
{
if (pick == TransitionLibraryPick.none)
{
// Only include loss combinations where all losses are included always
potentialLosses = potentialLosses.Where(losses =>
losses.All(loss => loss.TransitionLoss.Loss.Inclusion == LossInclusion.Always)).ToArray();
}
else if (useFilter)
{
// Exclude all losses which should never be included by default
potentialLosses = potentialLosses.Where(losses =>
losses.All(loss => loss.TransitionLoss.Loss.Inclusion != LossInclusion.Never)).ToArray();
}
if (!potentialLosses.Any())
{
potentialLosses = null;
}
}
// Return precursor ions
if (!useFilter || types.Contains(IonType.precursor))
{
bool libraryFilter = (pick == TransitionLibraryPick.all || pick == TransitionLibraryPick.filter);
foreach (var nodeTran in GetPrecursorTransitions(settings, mods, calcFilterPre, calcPredict,
precursorMz, isotopeDist, potentialLosses, transitionRanks, libraryFilter, useFilter))
{
if (minMz <= nodeTran.Mz && nodeTran.Mz <= maxMz)
{
yield return(nodeTran);
}
}
}
// Return special ions from settings, if this is a peptide
if (!IsCustomIon)
{
// This is a peptide, but it may have custom transitions (reporter ions), check those
foreach (var measuredIon in tranSettings.Filter.MeasuredIons.Where(m => m.IsCustom))
{
if (useFilter && measuredIon.IsOptional)
{
continue;
}
var tran = new Transition(this, measuredIon.Charge, null, measuredIon.CustomIon);
double mass = settings.GetFragmentMass(IsotopeLabelType.light, null, tran, null);
var nodeTran = new TransitionDocNode(tran, null, mass, null, null);
if (minMz <= nodeTran.Mz && nodeTran.Mz <= maxMz)
{
yield return(nodeTran);
}
}
}
// For small molecules we can't generate new nodes, so just mz filter those we have
foreach (var nodeTran in groupDocNode.Transitions.Where(tran => tran.Transition.IsNonPrecursorNonReporterCustomIon()))
{
if (minMz <= nodeTran.Mz && nodeTran.Mz <= maxMz)
{
yield return(nodeTran);
}
}
if (sequence == null) // Completely custom
{
yield break;
}
// If picking relies on library information
if (useFilter && pick != TransitionLibraryPick.none)
{
// If it is not yet loaded, or nothing got ranked, return an empty enumeration
if (!settings.PeptideSettings.Libraries.IsLoaded ||
(transitionRanks != null && transitionRanks.Count == 0))
{
yield break;
}
}
double[,] massesPredict = calcPredict.GetFragmentIonMasses(sequence);
int len = massesPredict.GetLength(1);
if (len == 0)
{
yield break;
}
double[,] massesFilter = massesPredict;
if (!ReferenceEquals(calcFilter, calcPredict))
{
// Get the normal m/z values for filtering, so that light and heavy
// ion picks will match.
massesFilter = calcFilter.GetFragmentIonMasses(sequence);
}
// Get types other than this to make sure matches are possible for all types
var listOtherTypes = new List <Tuple <TransitionGroupDocNode, IFragmentMassCalc> >();
foreach (var labelType in settings.PeptideSettings.Modifications.GetModificationTypes())
{
if (Equals(labelType, LabelType))
{
continue;
}
var calc = settings.GetFragmentCalc(labelType, mods);
if (calc == null)
{
continue;
}
var tranGroupOther = new TransitionGroup(Peptide, PrecursorCharge, labelType, false, DecoyMassShift);
var nodeGroupOther = new TransitionGroupDocNode(tranGroupOther, Annotations.EMPTY, settings, mods,
libInfo, ExplicitTransitionGroupValues.EMPTY, null, new TransitionDocNode[0], false);
listOtherTypes.Add(new Tuple <TransitionGroupDocNode, IFragmentMassCalc>(nodeGroupOther, calc));
}
// Loop over potential product ions picking transitions
foreach (IonType type in types)
{
// Precursor type is handled above.
if (type == IonType.precursor)
{
continue;
}
foreach (int charge in charges)
{
// Precursor charge can never be lower than product ion charge.
if (Math.Abs(PrecursorCharge) < Math.Abs(charge))
{
continue;
}
int start = 0, end = 0;
if (pick != TransitionLibraryPick.all)
{
start = startFinder.FindStartFragment(massesFilter, type, charge,
precursorMz, precursorMzWindow, out startMz);
end = endFinder.FindEndFragment(type, start, len);
if (Transition.IsCTerminal(type))
{
Helpers.Swap(ref start, ref end);
}
}
for (int i = 0; i < len; i++)
{
// Get the predicted m/z that would be used in the transition
double massH = massesPredict[(int)type, i];
foreach (var losses in CalcTransitionLosses(type, i, massType, potentialLosses))
{
double ionMz = SequenceMassCalc.GetMZ(Transition.CalcMass(massH, losses), charge);
// Make sure the fragment m/z value falls within the valid instrument range.
// CONSIDER: This means that a heavy transition might excede the instrument
// range where a light one is accepted, leading to a disparity
// between heavy and light transtions picked.
if (minMz > ionMz || ionMz > maxMz)
{
continue;
}
TransitionDocNode nodeTranReturn = null;
bool accept = true;
if (pick == TransitionLibraryPick.all || pick == TransitionLibraryPick.all_plus)
{
if (!useFilter)
{
nodeTranReturn = CreateTransitionNode(type, i, charge, massH, losses, transitionRanks);
accept = false;
}
else
{
if (IsMatched(transitionRanks, ionMz, type, charge, losses))
{
nodeTranReturn = CreateTransitionNode(type, i, charge, massH, losses, transitionRanks);
accept = false;
}
// If allowing library or filter, check the filter to decide whether to accept
else if (pick == TransitionLibraryPick.all_plus &&
tranSettings.Accept(sequence, precursorMzAccept, type, i, ionMz, start, end, startMz))
{
nodeTranReturn = CreateTransitionNode(type, i, charge, massH, losses, transitionRanks);
}
}
}
else if (tranSettings.Accept(sequence, precursorMzAccept, type, i, ionMz, start, end, startMz))
{
if (pick == TransitionLibraryPick.none)
{
nodeTranReturn = CreateTransitionNode(type, i, charge, massH, losses, transitionRanks);
}
else
{
if (IsMatched(transitionRanks, ionMz, type, charge, losses))
{
nodeTranReturn = CreateTransitionNode(type, i, charge, massH, losses, transitionRanks);
}
}
}
if (nodeTranReturn != null)
{
if (IsAvoidMismatchedIsotopeTransitions &&
!OtherLabelTypesAllowed(settings, minMz, maxMz, start, end, startMz, accept,
groupDocNode, nodeTranReturn, listOtherTypes))
{
continue;
}
Assume.IsTrue(minMz <= nodeTranReturn.Mz && nodeTranReturn.Mz <= maxMz);
yield return(nodeTranReturn);
}
}
}
}
}
}
public override bool TryGetLibInfo(LibKey key, out SpectrumHeaderInfo libInfo)
{
libInfo = null;
return(false);
}
public bool TryGetLibInfo(LibKey key, out SpectrumHeaderInfo libInfo)
{
Assume.IsTrue(IsLoaded);
foreach (Library lib in _libraries)
{
if (lib != null && lib.TryGetLibInfo(key, out libInfo))
return true;
}
libInfo = null;
return false;
}
public ViewLibraryPepInfo(LibKey key, SpectrumHeaderInfo libInfo = null)
{
Key = key;
LibInfo = libInfo;
UnmodifiedTargetText = GetUnmodifiedTargetText(key.LibraryKey);
}
public override bool TryGetLibInfo(LibKey key, out SpectrumHeaderInfo libInfo)
{
BiblioSpectrumInfo info;
if (_dictLibrary != null && _dictLibrary.TryGetValue(key, out info))
{
libInfo = new BiblioSpecSpectrumHeaderInfo(Name, info.Copies);
return true;
}
libInfo = null;
return false;
}
