protected override float Calculate(PeakScoringContext context, IPeptidePeakData <ISummaryPeakData> summaryPeakData)
{
float max = float.MinValue;
foreach (var peakData in GetIncludedGroups(summaryPeakData))
{
max = Math.Max(max, (float)CalcCountScore(peakData));
}
return(max != float.MinValue ? max : float.NaN);
}
protected override float Calculate(PeakScoringContext context,
IPeptidePeakData <ISummaryPeakData> summaryPeakData)
{
var massErrors = new List <double>();
var weights = new List <double>();
bool noTransitions = true;
bool allZeroWeights = true;
foreach (var tranGroup in GetTransitionGroups(summaryPeakData))
{
foreach (var pdTran in tranGroup.TransitionPeakData)
{
if (!IsIonType(pdTran.NodeTran))
{
continue;
}
noTransitions = false;
var peakData = pdTran.PeakData;
double?massError = peakData.MassError;
if (massError.HasValue)
{
massErrors.Add(MassErrorFunction(massError.Value));
double weight = GetWeight(peakData);
weights.Add(weight);
if (weight != 0)
{
allZeroWeights = false;
}
}
}
}
// If there are no qualifying transitions, return NaN
if (noTransitions)
{
return(float.NaN);
}
// If there are qualifying tranistions but they all have null mass error,
// then return maximum possible mass error
if (massErrors.Count == 0)
{
return((float)MaximumValue(context));
}
if (allZeroWeights)
{
weights = weights.ConvertAll(weight => 1.0);
}
var massStats = new Statistics(massErrors);
var weightsStats = new Statistics(weights);
return((float)massStats.Mean(weightsStats));
}
protected override float Calculate(PeakScoringContext context, IPeptidePeakData <ISummaryPeakData> summaryPeakData)
{
foreach (var groupPeakData in summaryPeakData.TransitionGroupPeakData)
{
foreach (var peakData in groupPeakData.TransitionPeakData)
{
if (peakData.PeakData.Identified != PeakIdentification.FALSE)
{
return(1);
}
}
}
return(0);
}
protected override float Calculate(PeakScoringContext context,
IPeptidePeakData <ISummaryPeakData> summaryPeakData)
{
bool noTransitions = true;
bool allZeroWeights = true;
// Use running mean calculation to avoid allocations which show up in a profiler
double weightedMeanMassError = 0;
double totalWeight = 0;
double unweightedMeanMassError = 0;
int totalSeen = 0;
foreach (var pdTran in GetIonTypes(GetTransitionGroups(summaryPeakData)))
{
noTransitions = false;
var peakData = pdTran.PeakData;
double?massError = peakData.MassError;
if (massError.HasValue)
{
double error = MassErrorFunction(massError.Value);
double weight = GetWeight(peakData);
if (weight != 0)
{
allZeroWeights = false;
totalWeight += weight;
weightedMeanMassError += (error - weightedMeanMassError) * weight / totalWeight;
}
totalSeen++;
unweightedMeanMassError += (error - unweightedMeanMassError) / totalSeen;
}
}
// If there are no qualifying transitions, return NaN
if (noTransitions)
{
return(float.NaN);
}
// If there are qualifying tranistions but they all have null mass error,
// then return maximum possible mass error
if (totalSeen == 0)
{
return((float)MaximumValue(context));
}
if (allZeroWeights)
{
return((float)unweightedMeanMassError);
}
return((float)weightedMeanMassError);
}
public float GetScore(PeakScoringContext context, IPeakFeatureCalculator calc)
{
var summaryCalc = calc as SummaryPeakFeatureCalculator;
if (summaryCalc != null)
{
return(summaryCalc.Calculate(context, this));
}
var groupPeakData = TransitionGroupPeakData.FirstOrDefault() as SummaryTransitionGroupPeakData;
if (groupPeakData != null)
{
return(groupPeakData.GetScore(calc.GetType()));
}
return(float.NaN);
}
protected override float Calculate(PeakScoringContext context,
IPeptidePeakData <IDetailedPeakData> summaryPeakData)
{
var tranGroupPeakDatas = GetTransitionGroups(summaryPeakData);
if (tranGroupPeakDatas.Count == 0)
{
return(float.NaN);
}
var snValues = new List <double>();
var weights = new List <double>();
foreach (var pdTran in GetIonTypes(tranGroupPeakDatas))
{
var peakData = pdTran.PeakData;
if (peakData == null || peakData.Intensities == null || peakData.Intensities.Length == 0)
{
continue;
}
double?snValue = GetSnValue(peakData);
if (snValue.HasValue)
{
snValues.Add(Math.Abs(snValue.Value));
weights.Add(GetWeight(peakData));
}
}
if (snValues.Count == 0)
{
return(float.NaN);
}
var snStats = new Statistics(snValues);
var weightsStats = new Statistics(weights);
if (weights.All(weight => weight == 0))
{
return(0);
}
return((float)snStats.Mean(weightsStats));
}
/// <summary>
/// No score caching for this calculator
/// </summary>
protected override float SetCachedScore(PeakScoringContext context,
IList <ITransitionGroupPeakData <IDetailedPeakData> > tranGroups, float score)
{
return(score);
}
protected override float Calculate(PeakScoringContext context, IPeptidePeakData <ISummaryPeakData> summaryPeakData)
{
return(MQuestHelpers.CalculateIdotp(context, summaryPeakData));
}
protected override double MaximumValue(PeakScoringContext context)
{
return(MQuestHelpers.GetMaximumPrecursorMassError(context));
}
protected abstract double MaximumValue(PeakScoringContext context);
protected abstract float Calculate(PeakScoringContext context, IPeptidePeakData <IDetailedPeakData> summaryPeakData);
public float Calculate(PeakScoringContext context, IPeptidePeakData peakGroupData)
{
return(Calculate(context, (IPeptidePeakData <IDetailedPeakData>)peakGroupData));
}
protected override float Calculate(PeakScoringContext context, IPeptidePeakData <ISummaryPeakData> summaryPeakData)
{
return(Score(SummedArea(summaryPeakData, false), SummedArea(summaryPeakData, true)));
}
private static IEnumerable <PeakTransitionGroupFeatures> GetPeakFeatures(this SrmDocument document,
PeptideGroupDocNode nodePepGroup,
PeptideDocNode nodePep,
IsotopeLabelType labelType,
IList <TransitionGroupDocNode> nodeGroups,
IList <IPeakFeatureCalculator> calcs,
IDictionary <int, int> runEnumDict,
bool verbose)
{
var chromatograms = document.Settings.MeasuredResults.Chromatograms;
float mzMatchTolerance = (float)document.Settings.TransitionSettings.Instrument.MzMatchTolerance;
foreach (var chromatogramSet in chromatograms)
{
ChromatogramGroupInfo[] arrayChromInfo;
if (!document.Settings.MeasuredResults.TryLoadChromatogram(chromatogramSet, nodePep, nodeGroups[0],
mzMatchTolerance, false, out arrayChromInfo))
{
continue;
}
foreach (var chromGroupInfo in arrayChromInfo)
{
var peakId = new PeakTransitionGroupId(nodePepGroup, nodePep, labelType, chromatogramSet, chromGroupInfo, runEnumDict);
var listRunFeatures = new List <PeakGroupFeatures>();
var summaryPeakData = new SummaryPeptidePeakData(document, nodePep, nodeGroups, chromatogramSet, chromGroupInfo);
var context = new PeakScoringContext(document);
while (summaryPeakData.NextPeakIndex())
{
if (!summaryPeakData.HasArea)
{
continue;
}
var features = new float[calcs.Count];
for (int i = 0; i < calcs.Count; i++)
{
features[i] = summaryPeakData.GetScore(context, calcs[i]);
}
// CONSIDER: Peak features can take up a lot of space in large scale DIA
// It may be possible to save even more by using a smaller struct
// when times are not required, which they are only for export
float retentionTime = 0, startTime = 0, endTime = 0;
if (verbose)
{
var peakTimes = summaryPeakData.RetentionTimeStatistics;
retentionTime = peakTimes.RetentionTime;
startTime = peakTimes.StartTime;
endTime = peakTimes.EndTime;
}
int peakIndex = summaryPeakData.UsedBestPeakIndex
? summaryPeakData.BestPeakIndex
: summaryPeakData.PeakIndex;
listRunFeatures.Add(new PeakGroupFeatures(peakIndex, retentionTime, startTime, endTime, features));
}
yield return(new PeakTransitionGroupFeatures(peakId, listRunFeatures.ToArray(), verbose));
}
}
}
public MzFilterPairs[] GetMzFilters(PeakScoringContext context)
{
var listMzFilters = new List <MzFilterPairs>();
var fullScan = context.Document.Settings.TransitionSettings.FullScan;
// Impossible to report precursor filter for results dependent DIA
if (fullScan.AcquisitionMethod == FullScanAcquisitionMethod.DIA && fullScan.IsolationScheme.FromResults)
{
return(listMzFilters.ToArray());
}
foreach (var transitionGroupPeakData in TransitionGroupPeakData)
{
double targetMzDia = 0, widthMzDia = 0;
if (fullScan.AcquisitionMethod == FullScanAcquisitionMethod.DIA)
{
var isolationWindows = fullScan.IsolationScheme.GetIsolationWindowsContaining(
transitionGroupPeakData.NodeGroup.PrecursorMz);
double start = double.MaxValue, end = double.MinValue;
foreach (var isolationWindow in isolationWindows)
{
start = Math.Min(start, isolationWindow.Start);
end = Math.Max(end, isolationWindow.End);
}
// This should not happen, but if no containing windows were found, give up.
if (start > end)
{
return(new MzFilterPairs[0]);
}
targetMzDia = (start + end) / 2;
widthMzDia = end - start;
}
foreach (var transitionPeakData in transitionGroupPeakData.TransitionPeakData)
{
// Skip forced integration peaks
if (transitionPeakData.PeakData == null)
{
continue;
}
// Default to SRM filters
var mzFilter = new MzFilterPairs
{
TargetPrecursorMz = transitionGroupPeakData.NodeGroup.PrecursorMz,
WidthPrecursorMz = 0.7,
TargetProductMz = transitionPeakData.NodeTran.Mz,
WidthProductMz = 0.7,
IsForcedIntegration = transitionPeakData.PeakData.IsForcedIntegration
};
if (fullScan.IsEnabled)
{
if (transitionPeakData.NodeTran.IsMs1)
{
// Move product mz to precursor mz for isotope transitions
mzFilter.TargetPrecursorMz = mzFilter.TargetProductMz.Value;
mzFilter.WidthPrecursorMz = fullScan.GetPrecursorFilterWindow(mzFilter.TargetPrecursorMz);
mzFilter.TargetProductMz = null;
mzFilter.WidthProductMz = null;
}
else
{
if (fullScan.AcquisitionMethod == FullScanAcquisitionMethod.Targeted)
{
mzFilter.WidthPrecursorMz = 2.0;
}
else if (fullScan.AcquisitionMethod == FullScanAcquisitionMethod.DIA)
{
mzFilter.TargetPrecursorMz = targetMzDia;
mzFilter.WidthPrecursorMz = widthMzDia;
}
mzFilter.WidthProductMz = fullScan.GetProductFilterWindow(mzFilter.TargetProductMz.Value);
}
}
listMzFilters.Add(mzFilter);
}
}
return(listMzFilters.ToArray());
}
private static IEnumerable <PeakTransitionGroupFeatures> GetPeakFeatures(this SrmDocument document,
PeptideGroupDocNode nodePepGroup,
PeptideDocNode nodePep,
IsotopeLabelType labelType,
IList <TransitionGroupDocNode> nodeGroups,
IList <IPeakFeatureCalculator> calcs,
IDictionary <int, int> runEnumDict,
bool includeMzFilters)
{
var chromatograms = document.Settings.MeasuredResults.Chromatograms;
float mzMatchTolerance = (float)document.Settings.TransitionSettings.Instrument.MzMatchTolerance;
foreach (var chromatogramSet in chromatograms)
{
ChromatogramGroupInfo[] arrayChromInfo;
if (!document.Settings.MeasuredResults.TryLoadChromatogram(chromatogramSet, nodePep, nodeGroups[0],
mzMatchTolerance, false, out arrayChromInfo))
{
continue;
}
foreach (var chromGroupInfo in arrayChromInfo)
{
var peakId = new PeakTransitionGroupId(nodePepGroup, nodePep, labelType, chromatogramSet, chromGroupInfo, runEnumDict);
var listRunFeatures = new List <PeakGroupFeatures>();
var summaryPeakData = new SummaryPeptidePeakData(document, nodePep, nodeGroups, chromatogramSet, chromGroupInfo);
var context = new PeakScoringContext(document);
while (summaryPeakData.NextPeakIndex())
{
if (!summaryPeakData.HasArea)
{
continue;
}
var features = new float[calcs.Count];
for (int i = 0; i < calcs.Count; i++)
{
features[i] = summaryPeakData.GetScore(context, calcs[i]);
}
MzFilterPairs[] mzFilters = null;
if (includeMzFilters)
{
mzFilters = summaryPeakData.GetMzFilters(context);
}
float retentionTime = summaryPeakData.RetentionTime;
float startTime = summaryPeakData.StartTime;
float endTime = summaryPeakData.EndTime;
bool isMaxPeakIndex = summaryPeakData.IsMaxPeakIndex;
listRunFeatures.Add(new PeakGroupFeatures(summaryPeakData.PeakIndex, retentionTime, startTime, endTime,
isMaxPeakIndex, features, mzFilters));
}
yield return(new PeakTransitionGroupFeatures(peakId, listRunFeatures.ToArray()));
}
}
}
