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; }