public TransitionDocNode[] GetMatchingTransitions(SrmSettings settings, TransitionGroupDocNode nodeGroupMatching, ExplicitMods mods) { // If no calculator for this type, then not possible to calculate transtions var calc = settings.GetFragmentCalc(LabelType, mods); if (calc == null) { return(null); } var listTrans = new List <TransitionDocNode>(); foreach (TransitionDocNode nodeTran in nodeGroupMatching.Children) { var nodeTranMatching = GetMatchingTransition(settings, nodeGroupMatching, nodeTran, calc); listTrans.Add(nodeTranMatching); } return(listTrans.ToArray()); }
public PrositMS2Spectrum(SrmSettings settings, PrositIntensityModel.PeptidePrecursorNCE peptidePrecursorNCE, int precursorIndex, PrositIntensityModel.PrositIntensityOutput prositIntensityOutput, IsotopeLabelType labelTypeOverride = null) { PeptidePrecursorNCE = peptidePrecursorNCE; Settings = settings; var precursor = peptidePrecursorNCE.NodeGroup; var peptide = peptidePrecursorNCE.NodePep; var calc = settings.GetFragmentCalc(IsotopeLabelType.light, peptide.ExplicitMods); var ionTable = calc.GetFragmentIonMasses(peptide.Target); // TODO: get mods and pass them as explicit mods above? var ions = ionTable.GetLength(1); var mis = new List <SpectrumPeaksInfo.MI>(ions * PrositConstants.IONS_PER_RESIDUE); for (int i = 0; i < ions; ++i) { var intensities = prositIntensityOutput.OutputRows[precursorIndex].Intensities[i].Intensities .Select(ReLu).ToArray(); var yMIs = CalcMIs(ionTable[IonType.y, ions - i - 1], intensities, 0); var bMIs = CalcMIs(ionTable[IonType.b, i], intensities, PrositConstants.IONS_PER_RESIDUE / 2); mis.AddRange(yMIs); mis.AddRange(bMIs); } var maxIntensity = mis.Max(mi => mi.Intensity); // Max Norm for (int i = 0; i < mis.Count; ++i) { mis[i] = new SpectrumPeaksInfo.MI { Mz = mis[i].Mz, Intensity = mis[i].Intensity / maxIntensity } } ; SpectrumPeaks = new SpectrumPeaksInfo(mis.ToArray()); }
private LibraryRankedSpectrumInfo(SpectrumPeaksInfo info, IsotopeLabelType labelType, TransitionGroupDocNode groupDocNode, SrmSettings settings, Target lookupSequence, ExplicitMods lookupMods, IEnumerable <Adduct> charges, IEnumerable <IonType> types, IEnumerable <Adduct> rankCharges, IEnumerable <IonType> rankTypes, double?score, bool useFilter, bool matchAll, int minPeaks) { LabelType = labelType; // Avoid ReSharper multiple enumeration warning var rankChargesArray = rankCharges.ToArray(); var rankTypesArray = rankTypes.ToArray(); TransitionGroup group = groupDocNode.TransitionGroup; bool isProteomic = group.IsProteomic; if (score == null && groupDocNode.HasLibInfo && groupDocNode.LibInfo is BiblioSpecSpectrumHeaderInfo libInfo) { Score = libInfo.Score; } else { Score = score; } if (!useFilter) { if (charges == null) { charges = GetRanked(rankChargesArray, isProteomic ? Transition.DEFAULT_PEPTIDE_CHARGES : Transition.DEFAULT_MOLECULE_CHARGES); } if (types == null) { types = GetRanked(rankTypesArray, isProteomic ? Transition.PEPTIDE_ION_TYPES : Transition.MOLECULE_ION_TYPES); } matchAll = true; } bool limitRanks = groupDocNode.IsCustomIon && // For small molecules, cap the number of ranked ions displayed if we don't have any peak metadata groupDocNode.Transitions.Any(t => string.IsNullOrEmpty(t.FragmentIonName)); RankParams rp = new RankParams { sequence = lookupSequence, precursorAdduct = group.PrecursorAdduct, adducts = charges ?? rankCharges, types = types ?? rankTypes, matchAll = matchAll, rankCharges = rankChargesArray.Select(a => Math.Abs(a.AdductCharge)).ToArray(), rankTypes = rankTypesArray, // Precursor isotopes will not be included in MS/MS, if they will be filtered // from MS1 excludePrecursorIsotopes = settings.TransitionSettings.FullScan.IsEnabledMs, tranSettings = settings.TransitionSettings, rankLimit = limitRanks ? settings.TransitionSettings.Libraries.IonCount : (int?)null }; // Get necessary mass calculators and masses var calcMatchPre = settings.GetPrecursorCalc(labelType, lookupMods); var calcMatch = isProteomic ? settings.GetFragmentCalc(labelType, lookupMods) : settings.GetDefaultFragmentCalc(); var calcPredict = isProteomic ? settings.GetFragmentCalc(group.LabelType, lookupMods) : calcMatch; if (isProteomic && rp.sequence.IsProteomic) { rp.precursorMz = SequenceMassCalc.GetMZ(calcMatchPre.GetPrecursorMass(rp.sequence), rp.precursorAdduct); rp.massPreMatch = calcMatch.GetPrecursorFragmentMass(rp.sequence); rp.massesMatch = calcMatch.GetFragmentIonMasses(rp.sequence); rp.knownFragments = null; } else if (!isProteomic && !rp.sequence.IsProteomic) { string isotopicForumla; rp.precursorMz = SequenceMassCalc.GetMZ(calcMatchPre.GetPrecursorMass(rp.sequence.Molecule, null, rp.precursorAdduct, out isotopicForumla), rp.precursorAdduct); rp.massPreMatch = calcMatch.GetPrecursorFragmentMass(rp.sequence); // rp.massesMatch = calcMatch.GetFragmentIonMasses(rp.molecule); CONSIDER, for some molecule types someday? // For small molecules we can't predict fragmentation, so just use those we have // Older Resharper code inspection implementations insist on warning here // Resharper disable PossibleMultipleEnumeration var existing = groupDocNode.Transitions.Where(tran => tran.Transition.IsNonPrecursorNonReporterCustomIon()).Select(t => t.Transition.CustomIon.GetMass(MassType.Monoisotopic)).ToArray(); rp.massesMatch = new IonTable <TypedMass>(IonType.custom, existing.Length); for (var i = 0; i < existing.Length; i++) { rp.massesMatch[IonType.custom, i] = existing[i]; } // Resharper restore PossibleMultipleEnumeration rp.knownFragments = groupDocNode.Transitions.Where(tran => tran.Transition.IsNonPrecursorNonReporterCustomIon()).Select(t => new KnownFragment { Adduct = t.Transition.Adduct, Name = t.GetFragmentIonName(CultureInfo.CurrentCulture, settings.TransitionSettings.Libraries.IonMatchTolerance), Mz = t.Mz }).ToList(); } else { rp.precursorMz = 0.0; rp.massPreMatch = TypedMass.ZERO_MONO_MASSH; rp.massesMatch = IonTable <TypedMass> .EMPTY; rp.knownFragments = null; } rp.massPrePredict = rp.massPreMatch; rp.massesPredict = rp.massesMatch; if (!ReferenceEquals(calcPredict, calcMatch)) { rp.massPrePredict = calcPredict.GetPrecursorFragmentMass(rp.sequence); if (rp.sequence.IsProteomic) // CONSIDER - eventually we may be able to predict fragments for small molecules? { rp.massesPredict = calcPredict.GetFragmentIonMasses(rp.sequence); } } // Get values of interest from the settings. var tranSettings = settings.TransitionSettings; var predict = tranSettings.Prediction; var filter = tranSettings.Filter; var libraries = tranSettings.Libraries; var instrument = tranSettings.Instrument; // Get potential losses to all fragments in this peptide rp.massType = predict.FragmentMassType; rp.potentialLosses = TransitionGroup.CalcPotentialLosses(rp.sequence, settings.PeptideSettings.Modifications, lookupMods, rp.massType); // Create arrays because ReadOnlyCollection enumerators are too slow // In some cases these collections must be enumerated for every ion // allowed in the library specturm. rp.startFinder = filter.FragmentRangeFirst; rp.endFinder = filter.FragmentRangeLast; // Get library settings Tolerance = libraries.IonMatchTolerance; rp.tolerance = Tolerance; rp.pick = tranSettings.Libraries.Pick; int ionMatchCount = libraries.IonCount; // If no library filtering will happen, return all rankings for view in the UI if (!useFilter || rp.pick == TransitionLibraryPick.none) { if (rp.pick == TransitionLibraryPick.none) { rp.pick = TransitionLibraryPick.all; } ionMatchCount = -1; } // Get instrument settings rp.minMz = instrument.MinMz; rp.maxMz = instrument.MaxMz; // Get the library spectrum mass-intensity pairs IList <SpectrumPeaksInfo.MI> listMI = info.Peaks; // Because sorting and matching observed ions with predicted // ions appear as bottlenecks in a profiler, a minimum number // of peaks may be supplied to allow the use of a 2-phase linear // filter that can significantly reduce the number of peaks // needing the O(n*log(n)) sorting and the O(n*m) matching. int len = listMI.Count; float intensityCutoff = 0; if (minPeaks != -1) { // Start searching for good cut-off at mean intensity. double totalIntensity = info.Intensities.Sum(); FindIntensityCutoff(listMI, 0, (float)(totalIntensity / len) * 2, minPeaks, 1, ref intensityCutoff, ref len); } // Create filtered peak array storing original index for m/z ordering // to avoid needing to sort to return to this order. RankedMI[] arrayRMI = new RankedMI[len]; // Detect when m/z values are out of order, and use the expensive sort // by m/z to correct this. double lastMz = double.MinValue; bool sortMz = false; for (int i = 0, j = 0, lenOrig = listMI.Count; i < lenOrig; i++) { SpectrumPeaksInfo.MI mi = listMI[i]; if (mi.Intensity >= intensityCutoff || intensityCutoff == 0) { arrayRMI[j] = new RankedMI(mi, j); j++; } if (ionMatchCount == -1) { if (mi.Mz < lastMz) { sortMz = true; } lastMz = mi.Mz; } } // The one expensive sort is used to determine rank order // by intensity, or m/z in case of a tie. Array.Sort(arrayRMI, OrderIntensityDesc); RankedMI[] arrayResult = new RankedMI[ionMatchCount != -1 ? ionMatchCount : arrayRMI.Length]; foreach (RankedMI rmi in arrayRMI) { rmi.CalculateRank(rp); // If not filtering for only the highest ionMatchCount ranks if (ionMatchCount == -1) { // Put the ranked record back where it started in the // m/z ordering to avoid a second sort. arrayResult[rmi.IndexMz] = rmi; } // Otherwise, if this ion was ranked, add it to the result array else if (rmi.Rank > 0) { int countRanks = rmi.Rank; arrayResult[countRanks - 1] = rmi; // And stop when the array is full if (countRanks == ionMatchCount) { break; } } } // Is this a theoretical library with no intensity variation? If so it can't be ranked. // If it has any interesting peak annotations, pass those through if (rp.Ranked == 0 && arrayRMI.All(rmi => rmi.Intensity == arrayRMI[0].Intensity)) { // Only do this if we have been asked to limit the ions matched, and there are any annotations if (ionMatchCount != -1 && arrayRMI.Any(rmi => rmi.HasAnnotations)) { // Pass through anything with an annotation as being of probable interest arrayResult = arrayRMI.Where(rmi => rmi.HasAnnotations).ToArray(); ionMatchCount = -1; } } // If not enough ranked ions were found, fill the rest of the results array if (ionMatchCount != -1) { for (int i = rp.Ranked; i < ionMatchCount; i++) { arrayResult[i] = RankedMI.EMPTY; } } // If all ions are to be included, and some were found out of order, then // the expensive full sort by m/z is necesary. else if (sortMz) { Array.Sort(arrayResult, OrderMz); } _spectrum = MakeReadOnly(arrayResult); }
public static Size RenderTip(PeptideDocNode nodePep, TransitionGroupDocNode nodeGroup, TransitionDocNode nodeTranSelected, SrmSettings settings, Graphics g, Size sizeMax, bool draw) { if (nodeGroup.TransitionGroup.IsCustomIon) // TODO(bspratt) this seems to leave out a lot of detail { var customTable = new TableDesc(); using (RenderTools rt = new RenderTools()) { customTable.AddDetailRow(Resources.TransitionGroupTreeNode_RenderTip_Molecule, nodeGroup.CustomMolecule.Name, rt); customTable.AddDetailRow(Resources.TransitionGroupTreeNode_RenderTip_Precursor_charge, nodeGroup.TransitionGroup.PrecursorAdduct.AdductCharge.ToString(LocalizationHelper.CurrentCulture), rt); customTable.AddDetailRow(Resources.TransitionGroupTreeNode_RenderTip_Precursor_mz, string.Format(@"{0:F04}", nodeGroup.PrecursorMz), rt); if (nodeGroup.CustomMolecule.Formula != null) { customTable.AddDetailRow(Resources.TransitionTreeNode_RenderTip_Formula, nodeGroup.CustomMolecule.Formula + nodeGroup.TransitionGroup.PrecursorAdduct.AdductFormula.ToString(LocalizationHelper.CurrentCulture), rt); } SizeF size = customTable.CalcDimensions(g); customTable.Draw(g); return(new Size((int)size.Width + 2, (int)size.Height + 2)); } } ExplicitMods mods = (nodePep != null ? nodePep.ExplicitMods : null); IEnumerable <DocNode> choices = nodeGroup.GetPrecursorChoices(settings, mods, true).ToArray(); HashSet <DocNode> chosen = new HashSet <DocNode>(nodeGroup.Children); // Make sure all chosen peptides get listed HashSet <DocNode> setChoices = new HashSet <DocNode>(choices); setChoices.UnionWith(chosen); choices = setChoices.ToArray(); Transition tranSelected = (nodeTranSelected != null ? nodeTranSelected.Transition : null); IFragmentMassCalc calc = settings.GetFragmentCalc(nodeGroup.TransitionGroup.LabelType, mods); var aa = nodeGroup.TransitionGroup.Peptide.Target.Sequence; // We handled custom ions above, and returned var masses = calc.GetFragmentIonMasses(nodeGroup.TransitionGroup.Peptide.Target); var filter = settings.TransitionSettings.Filter; // Get charges and type pairs, making sure all chosen charges are included var setCharges = new HashSet <Adduct>(filter.PeptideProductCharges.Where(charge => Math.Abs(charge.AdductCharge) <= Math.Abs(nodeGroup.TransitionGroup.PrecursorCharge) && Math.Sign(charge.AdductCharge) == Math.Sign(nodeGroup.TransitionGroup.PrecursorCharge))); HashSet <IonType> setTypes = new HashSet <IonType>(filter.PeptideIonTypes); foreach (TransitionDocNode nodTran in chosen) { var type = nodTran.Transition.IonType; if (!Transition.IsPeptideFragment(type)) { continue; } setCharges.Add(nodTran.Transition.Adduct); setTypes.Add(type); } setTypes.RemoveWhere(t => !Transition.IsPeptideFragment(t)); var charges = setCharges.Where(c => c.IsProteomic).ToArray(); Array.Sort(charges); IonType[] types = Transition.GetTypePairs(setTypes); var tableDetails = new TableDesc(); var table = new TableDesc(); using (RenderTools rt = new RenderTools()) { var seqModified = GetModifiedSequence(nodePep, nodeGroup, settings); if (!Equals(seqModified, nodeGroup.TransitionGroup.Peptide.Target)) { tableDetails.AddDetailRow(Resources.TransitionGroupTreeNode_RenderTip_Modified, seqModified.Sequence, rt); } var precursorCharge = nodeGroup.TransitionGroup.PrecursorAdduct; var precursorMz = nodeGroup.PrecursorMz; tableDetails.AddDetailRow(Resources.TransitionGroupTreeNode_RenderTip_Precursor_charge, precursorCharge.AdductCharge.ToString(LocalizationHelper.CurrentCulture), rt); tableDetails.AddDetailRow(Resources.TransitionGroupTreeNode_RenderTip_Precursor_mz, string.Format(@"{0:F04}", precursorMz), rt); tableDetails.AddDetailRow(Resources.TransitionGroupTreeNode_RenderTip_Precursor_mh, string.Format(@"{0:F04}", nodeGroup.GetPrecursorIonMass()), rt); int?decoyMassShift = nodeGroup.TransitionGroup.DecoyMassShift; if (decoyMassShift.HasValue) { tableDetails.AddDetailRow(Resources.TransitionGroupTreeNode_RenderTip_Decoy_Mass_Shift, decoyMassShift.Value.ToString(LocalizationHelper.CurrentCulture), rt); } if (nodeGroup.HasLibInfo) { foreach (KeyValuePair <PeptideRankId, string> pair in nodeGroup.LibInfo.RankValues) { tableDetails.AddDetailRow(pair.Key.Label, pair.Value, rt); } } if (charges.Length > 0 && types.Length > 0) { var headers = new RowDesc { CreateHead(@"#", rt), CreateHead(@"AA", rt), CreateHead(@"#", rt) }; foreach (var charge in charges) { string plusSub = Transition.GetChargeIndicator(charge); foreach (IonType type in types) { CellDesc cell = CreateHead(type.ToString().ToLower() + plusSub, rt); if (Transition.IsNTerminal(type)) { headers.Insert(0, cell); } else { headers.Add(cell); } } } table.Add(headers); int len = aa.Length; for (int i = 0; i < len; i++) { CellDesc cellAA = CreateRowLabel(aa.Substring(i, 1), rt); cellAA.Align = StringAlignment.Center; var row = new RowDesc { CreateRowLabel(i == len - 1 ? string.Empty : (i + 1).ToString(CultureInfo.InvariantCulture), rt), cellAA, CreateRowLabel(i == 0 ? string.Empty : (len - i).ToString(CultureInfo.InvariantCulture), rt) }; foreach (var charge in charges) { foreach (IonType type in types) { CellDesc cell; if (Transition.IsNTerminal(type)) { if (i == len - 1) { cell = CreateData(string.Empty, rt); } else { var massH = masses[type, i]; cell = CreateIon(type, i + 1, massH, charge, choices, chosen, tranSelected, rt); } row.Insert(0, cell); } else { if (i == 0) { cell = CreateData(string.Empty, rt); } else { var massH = masses[type, i - 1]; cell = CreateIon(type, len - i, massH, charge, choices, chosen, tranSelected, rt); } row.Add(cell); } } } table.Add(row); } } SizeF sizeDetails = tableDetails.CalcDimensions(g); sizeDetails.Height += TableDesc.TABLE_SPACING; // Spacing between details and fragments SizeF size = table.CalcDimensions(g); if (draw) { tableDetails.Draw(g); g.TranslateTransform(0, sizeDetails.Height); table.Draw(g); g.TranslateTransform(0, -sizeDetails.Height); } int width = (int)Math.Round(Math.Max(sizeDetails.Width, size.Width)); int height = (int)Math.Round(sizeDetails.Height + size.Height); return(new Size(width + 2, height + 2)); } }
private LibraryRankedSpectrumInfo(SpectrumPeaksInfo info, IsotopeLabelType labelType, TransitionGroup group, SrmSettings settings, string lookupSequence, ExplicitMods lookupMods, IEnumerable <int> charges, IEnumerable <IonType> types, IEnumerable <int> rankCharges, IEnumerable <IonType> rankTypes, bool useFilter, bool matchAll, int minPeaks) { LabelType = labelType; // Avoid ReSharper multiple enumeration warning var rankChargesArray = rankCharges.ToArray(); var rankTypesArray = rankTypes.ToArray(); if (!useFilter) { if (charges == null) { charges = GetRanked(rankChargesArray, Transition.ALL_CHARGES); } if (types == null) { types = GetRanked(rankTypesArray, Transition.ALL_TYPES); } matchAll = true; } RankParams rp = new RankParams { sequence = lookupSequence, precursorCharge = group.PrecursorCharge, charges = charges ?? rankCharges, types = types ?? rankTypes, matchAll = matchAll, rankCharges = rankChargesArray, rankTypes = rankTypesArray, // Precursor isotopes will not be included in MS/MS, if they will be filtered // from MS1 excludePrecursorIsotopes = settings.TransitionSettings.FullScan.IsEnabledMs, tranSettings = settings.TransitionSettings }; // Get necessary mass calculators and masses var calcMatchPre = settings.GetPrecursorCalc(labelType, lookupMods); var calcMatch = settings.GetFragmentCalc(labelType, lookupMods); var calcPredict = settings.GetFragmentCalc(group.LabelType, lookupMods); if (!string.IsNullOrEmpty(rp.sequence)) { rp.precursorMz = SequenceMassCalc.GetMZ(calcMatchPre.GetPrecursorMass(rp.sequence), rp.precursorCharge); rp.massPreMatch = calcMatch.GetPrecursorFragmentMass(rp.sequence); rp.massesMatch = calcMatch.GetFragmentIonMasses(rp.sequence); } else { rp.precursorMz = 0.0; rp.massPreMatch = 0.0; rp.massesMatch = new double[0, 0]; } rp.massPrePredict = rp.massPreMatch; rp.massesPredict = rp.massesMatch; if (!ReferenceEquals(calcPredict, calcMatch) && !string.IsNullOrEmpty(rp.sequence)) { rp.massPrePredict = calcPredict.GetPrecursorFragmentMass(rp.sequence); rp.massesPredict = calcPredict.GetFragmentIonMasses(rp.sequence); } // Get values of interest from the settings. var tranSettings = settings.TransitionSettings; var predict = tranSettings.Prediction; var filter = tranSettings.Filter; var libraries = tranSettings.Libraries; var instrument = tranSettings.Instrument; // Get potential losses to all fragments in this peptide rp.massType = predict.FragmentMassType; rp.potentialLosses = TransitionGroup.CalcPotentialLosses(rp.sequence, settings.PeptideSettings.Modifications, lookupMods, rp.massType); // Create arrays because ReadOnlyCollection enumerators are too slow // In some cases these collections must be enumerated for every ion // allowed in the library specturm. rp.startFinder = filter.FragmentRangeFirst; rp.endFinder = filter.FragmentRangeLast; // Get library settings Tolerance = libraries.IonMatchTolerance; rp.tolerance = Tolerance; rp.pick = tranSettings.Libraries.Pick; int ionMatchCount = libraries.IonCount; // If no library filtering will happen, return all rankings for view in the UI if (!useFilter || rp.pick == TransitionLibraryPick.none) { if (rp.pick == TransitionLibraryPick.none) { rp.pick = TransitionLibraryPick.all; } ionMatchCount = -1; } // Get instrument settings rp.minMz = instrument.MinMz; rp.maxMz = instrument.MaxMz; // Get the library spectrum mass-intensity pairs IList <SpectrumPeaksInfo.MI> listMI = info.Peaks; // Because sorting and matching observed ions with predicted // ions appear as bottlenecks in a profiler, a minimum number // of peaks may be supplied to allow the use of a 2-phase linear // filter that can significantly reduce the number of peaks // needing the O(n*log(n)) sorting and the O(n*m) matching. int len = listMI.Count; float intensityCutoff = 0; if (minPeaks != -1) { // Start searching for good cut-off at mean intensity. double totalIntensity = info.Intensities.Sum(); FindIntensityCutoff(listMI, 0, (float)(totalIntensity / len) * 2, minPeaks, 1, ref intensityCutoff, ref len); } // Create filtered peak array storing original index for m/z ordering // to avoid needing to sort to return to this order. RankedMI[] arrayRMI = new RankedMI[len]; // Detect when m/z values are out of order, and use the expensive sort // by m/z to correct this. double lastMz = double.MinValue; bool sortMz = false; for (int i = 0, j = 0, lenOrig = listMI.Count; i < lenOrig; i++) { SpectrumPeaksInfo.MI mi = listMI[i]; if (mi.Intensity >= intensityCutoff || intensityCutoff == 0) { arrayRMI[j] = new RankedMI(mi, j); j++; } if (ionMatchCount == -1) { if (mi.Mz < lastMz) { sortMz = true; } lastMz = mi.Mz; } } // The one expensive sort is used to determine rank order // by intensity. Array.Sort(arrayRMI, OrderIntensityDesc); RankedMI[] arrayResult = new RankedMI[ionMatchCount != -1 ? ionMatchCount : arrayRMI.Length]; foreach (RankedMI rmi in arrayRMI) { rmi.CalculateRank(rp); // If not filtering for only the highest ionMatchCount ranks if (ionMatchCount == -1) { // Put the ranked record back where it started in the // m/z ordering to avoid a second sort. arrayResult[rmi.IndexMz] = rmi; } // Otherwise, if this ion was ranked, add it to the result array else if (rmi.Rank > 0) { int countRanks = rmi.Rank; arrayResult[countRanks - 1] = rmi; // And stop when the array is full if (countRanks == ionMatchCount) { break; } } } // If not enough ranked ions were found, fill the rest of the results array if (ionMatchCount != -1) { for (int i = rp.Ranked; i < ionMatchCount; i++) { arrayResult[i] = RankedMI.EMPTY; } } // If all ions are to be included, and some were found out of order, then // the expensive full sort by m/z is necesary. else if (sortMz) { Array.Sort(arrayResult, OrderMz); } _spectrum = MakeReadOnly(arrayResult); }
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 SpectrumRanker(TargetInfo targetInfo, SrmSettings settings, FragmentFilter fragmentFilter) { TargetInfoObj = targetInfo; FragmentFilterObj = fragmentFilter; var groupDocNode = TargetInfoObj.TransitionGroupDocNode; TransitionGroup group = groupDocNode.TransitionGroup; bool isProteomic = group.IsProteomic; bool limitRanks = groupDocNode.IsCustomIon && // For small molecules, cap the number of ranked ions displayed if we don't have any peak metadata groupDocNode.Transitions.Any(t => string.IsNullOrEmpty(t.FragmentIonName)); RankLimit = limitRanks ? settings.TransitionSettings.Libraries.IonCount : (int?)null; // Get necessary mass calculators and masses var labelType = targetInfo.SpectrumLabelType; var lookupMods = targetInfo.LookupMods; var calcMatchPre = settings.GetPrecursorCalc(labelType, lookupMods); var calcMatch = isProteomic ? settings.GetFragmentCalc(labelType, lookupMods) : settings.GetDefaultFragmentCalc(); var calcPredict = isProteomic ? settings.GetFragmentCalc(group.LabelType, lookupMods) : calcMatch; MoleculeMasses moleculeMasses; if (null != lookupMods && lookupMods.HasCrosslinks) { moleculeMasses = GetCrosslinkMasses(settings); } else { if (isProteomic && Sequence.IsProteomic) { moleculeMasses = new MoleculeMasses( SequenceMassCalc.GetMZ(calcMatchPre.GetPrecursorMass(Sequence), PrecursorAdduct), new IonMasses(calcMatch.GetPrecursorFragmentMass(Sequence), calcMatch.GetFragmentIonMasses(Sequence))); } else if (!isProteomic && !Sequence.IsProteomic) { string isotopicFormula; var knownFragments = new List <MatchedFragmentIon>(); foreach (var tran in groupDocNode.Transitions) { if (tran.Transition.IsNonPrecursorNonReporterCustomIon()) { knownFragments.Add(new MatchedFragmentIon(IonType.custom, knownFragments.Count + 1, tran.Transition.Adduct, tran.GetFragmentIonName(CultureInfo.CurrentCulture, settings.TransitionSettings.Libraries.IonMatchTolerance), null, tran.Mz)); } } var ionMasses = new IonMasses(calcMatch.GetPrecursorFragmentMass(Sequence), IonTable <TypedMass> .EMPTY) .ChangeKnownFragments(knownFragments); moleculeMasses = new MoleculeMasses( SequenceMassCalc.GetMZ( calcMatchPre.GetPrecursorMass(Sequence.Molecule, null, PrecursorAdduct, out isotopicFormula), PrecursorAdduct), ionMasses); } else { moleculeMasses = new MoleculeMasses(0.0, new IonMasses(TypedMass.ZERO_MONO_MASSH, IonTable <TypedMass> .EMPTY)); } if (!ReferenceEquals(calcPredict, calcMatch)) { var ionTable = moleculeMasses.MatchIonMasses.FragmentMasses; if (Sequence.IsProteomic ) // CONSIDER - eventually we may be able to predict fragments for small molecules? { ionTable = calcPredict.GetFragmentIonMasses(Sequence); } moleculeMasses = moleculeMasses.ChangePredictIonMasses(new IonMasses( calcPredict.GetPrecursorFragmentMass(Sequence), ionTable)); } } MoleculeMassesObj = moleculeMasses; // Get values of interest from the settings. TransitionSettings = settings.TransitionSettings; // Get potential losses to all fragments in this peptide PotentialLosses = TransitionGroup.CalcPotentialLosses(Sequence, settings.PeptideSettings.Modifications, lookupMods, MassType); }