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