public static string GetResultsText(DisplaySettings displaySettings, TransitionGroupDocNode nodeGroup)
{
float? libraryProduct = nodeGroup.GetLibraryDotProduct(displaySettings.ResultsIndex);
float? isotopeProduct = nodeGroup.GetIsotopeDotProduct(displaySettings.ResultsIndex);
RatioValue ratio = null;
if (displaySettings.NormalizationMethod is NormalizationMethod.RatioToLabel ratioToLabel)
{
ratio = displaySettings.NormalizedValueCalculator.GetTransitionGroupRatioValue(ratioToLabel,
displaySettings.NodePep, nodeGroup, nodeGroup.GetChromInfoEntry(displaySettings.ResultsIndex));
}
if (null == ratio && !isotopeProduct.HasValue && !libraryProduct.HasValue)
{
return(string.Empty);
}
StringBuilder sb = new StringBuilder(@" (");
int len = sb.Length;
if (isotopeProduct.HasValue)
{
sb.Append(string.Format(@"idotp {0}", isotopeProduct.Value.ToString(DOTP_FORMAT)));
}
if (libraryProduct.HasValue)
{
if (sb.Length > len)
{
sb.Append(CS_SEPARATOR);
}
sb.Append(string.Format(@"dotp {0}", libraryProduct.Value.ToString(DOTP_FORMAT)));
}
if (ratio != null)
{
if (sb.Length > len)
{
sb.Append(CS_SEPARATOR);
}
if (!double.IsNaN(ratio.StdDev))
{
sb.Append(string.Format(@"rdotp {0}", ratio.DotProduct.ToString(DOTP_FORMAT)));
sb.Append(CS_SEPARATOR);
}
sb.Append(string.Format(Resources.TransitionGroupTreeNode_GetResultsText_total_ratio__0__,
MathEx.RoundAboveZero(ratio.Ratio, 2, 4)));
}
sb.Append(@")");
return(sb.ToString());
}
public static string GetResultsText(TransitionGroupDocNode nodeGroup,
PeptideDocNode nodePep, int indexResult, int indexRatio)
{
float? libraryProduct = nodeGroup.GetLibraryDotProduct(indexResult);
float? isotopeProduct = nodeGroup.GetIsotopeDotProduct(indexResult);
RatioValue ratio = nodeGroup.GetPeakAreaRatio(indexResult, indexRatio);
if (null == ratio && !isotopeProduct.HasValue && !libraryProduct.HasValue)
{
return(string.Empty);
}
StringBuilder sb = new StringBuilder(@" (");
int len = sb.Length;
if (isotopeProduct.HasValue)
{
sb.Append(string.Format(@"idotp {0}", isotopeProduct.Value.ToString(DOTP_FORMAT)));
}
if (libraryProduct.HasValue)
{
if (sb.Length > len)
{
sb.Append(CS_SEPARATOR);
}
sb.Append(string.Format(@"dotp {0}", libraryProduct.Value.ToString(DOTP_FORMAT)));
}
if (ratio != null)
{
if (sb.Length > len)
{
sb.Append(CS_SEPARATOR);
}
if (!double.IsNaN(ratio.StdDev))
{
sb.Append(string.Format(@"rdotp {0}", ratio.DotProduct.ToString(DOTP_FORMAT)));
sb.Append(CS_SEPARATOR);
}
sb.Append(string.Format(Resources.TransitionGroupTreeNode_GetResultsText_total_ratio__0__,
MathEx.RoundAboveZero(ratio.Ratio, 2, 4)));
}
sb.Append(@")");
return(sb.ToString());
}
public static RatioPropertyDescriptor GetProperty(SrmDocument document, Type componentType, string propertyName)
{
string prefix;
IList <string> parts;
if (!TryParseProperty(propertyName, out prefix, out parts))
{
return(null);
}
var modifications = document.Settings.PeptideSettings.Modifications;
if (componentType == typeof(PeptideResult))
{
string displayName;
Func <PeptideResult, double?> getterFunc;
if (parts.Count == 0)
{
return(null);
}
string format;
string labelColumnPart = parts[0];
var labelType = FindLabel(modifications.GetModificationTypes(), labelColumnPart);
if (parts.Count == 1)
{
getterFunc = peptideResult =>
RatioValue.GetRatio(FindPeptideLabelRatio(peptideResult, labelType, null).Ratio);
displayName = string.Format("Ratio{0}ToGlobalStandards", labelColumnPart); // Not L10N
format = Formats.GLOBAL_STANDARD_RATIO;
}
else if (parts.Count != 2)
{
return(null);
}
else
{
string standardColumnPart = parts[1];
var standardType = FindLabel(modifications.RatioInternalStandardTypes, standardColumnPart);
if (prefix == RATIO_PREFIX)
{
getterFunc = peptideResult =>
RatioValue.GetRatio(FindPeptideLabelRatio(peptideResult, labelType, standardType).Ratio);
displayName = string.Format("Ratio{0}To{1}", labelColumnPart, standardColumnPart); // Not L10N
format = Formats.STANDARD_RATIO;
}
else if (prefix == RDOTP_PREFIX)
{
getterFunc = peptideResult =>
RatioValue.GetDotProduct(FindPeptideLabelRatio(peptideResult, labelType, standardType).Ratio);
displayName = string.Format("DotProduct{0}To{1}", labelColumnPart, standardColumnPart); // Not L10N
format = Formats.STANDARD_RATIO;
}
else
{
return(null);
}
}
return(MakeRatioProperty(propertyName, displayName, format, getterFunc));
}
if (componentType == typeof(PrecursorResult))
{
string format;
Func <PrecursorResult, double?> getterFunc;
string displayName;
if (parts.Count == 0)
{
if (prefix != RATIO_GS_PREFIX)
{
return(null);
}
getterFunc = precursorResult => RatioValue.GetRatio(precursorResult.ChromInfo.Ratios[precursorResult.ChromInfo.Ratios.Count - 1]);
displayName = "TotalAreaRatioToGlobalStandards"; // Not L10N
format = Formats.GLOBAL_STANDARD_RATIO;
}
else if (parts.Count != 1)
{
return(null);
}
else
{
format = Formats.STANDARD_RATIO;
string labelColumnPart = parts[0];
int ratioIndex = IndexOf(modifications.RatioInternalStandardTypes, labelColumnPart);
if (prefix == RATIO_PREFIX)
{
getterFunc = precursorResult =>
{
if (ratioIndex < 0 || ratioIndex >= precursorResult.ChromInfo.Ratios.Count)
{
return(null);
}
return(RatioValue.GetRatio(precursorResult.ChromInfo.Ratios[ratioIndex]));
};
displayName = string.Format("TotalAreaRatioTo{0}", labelColumnPart); // Not L10N
}
else if (prefix == RDOTP_PREFIX)
{
getterFunc = precursorResult =>
{
if (ratioIndex < 0 || ratioIndex >= precursorResult.ChromInfo.Ratios.Count)
{
return(null);
}
return(RatioValue.GetDotProduct(precursorResult.ChromInfo.Ratios[ratioIndex]));
};
displayName = string.Format("DotProductTo{0}", labelColumnPart); // Not L10N
}
else
{
return(null);
}
}
return(MakeRatioProperty(propertyName, displayName, format, getterFunc));
}
if (componentType == typeof(TransitionResult))
{
string format;
Func <TransitionResult, double?> getterFunc;
string displayName;
if (parts.Count == 0)
{
if (prefix != RATIO_GS_PREFIX)
{
return(null);
}
getterFunc = transitionResult => transitionResult.ChromInfo.Ratios[transitionResult.ChromInfo.Ratios.Count - 1];
displayName = "AreaRatioToGlobalStandards"; // Not L10N
format = Formats.GLOBAL_STANDARD_RATIO;
}
else if (prefix != RATIO_PREFIX || parts.Count != 1)
{
return(null);
}
else
{
format = Formats.STANDARD_RATIO;
string labelColumnPart = parts[0];
int ratioIndex = IndexOf(modifications.RatioInternalStandardTypes, labelColumnPart);
getterFunc = transitionResult =>
{
if (ratioIndex < 0 || ratioIndex >= transitionResult.ChromInfo.Ratios.Count)
{
return(null);
}
return(transitionResult.ChromInfo.Ratios[ratioIndex]);
};
displayName = string.Format("AreaRatioTo{0}", labelColumnPart); // Not L10N
}
return(MakeRatioProperty(propertyName, displayName, format, getterFunc));
}
return(null);
}
private static MediaQuery ParseMediaClause(string media, IPosition forPosition)
{
if (!media.StartsWith("(") || !media.EndsWith(")"))
{
Current.RecordError(ErrorType.Parser, forPosition, "Media features must be enclosed in paranthesis, found '" + media + "'");
throw new StoppedParsingException();
}
// Trim leading ( and trailing )
media = media.Substring(1, media.Length - 2).Trim();
var i = media.IndexOf(':');
if (i == -1)
{
if (!IsValidFeatureName(media))
{
Current.RecordError(ErrorType.Parser, forPosition, "Media feature not recognized, found '" + media + "'");
throw new StoppedParsingException();
}
return(new FeatureMedia(media, forPosition));
}
var feature = media.Substring(0, i).Trim();
var valueStr = media.Substring(i + 1).Trim();
var value = MoreValueParser.Parse(valueStr, forPosition);
var math = value as MathValue;
if (math != null)
{
// Ratio check
if (math.Operator == Operator.Div && IsRatioFeature(feature))
{
var ratio = new RatioValue(math.LeftHand, math.RightHand);
ratio.Start = value.Start;
ratio.Stop = value.Stop;
ratio.FilePath = value.FilePath;
value = ratio;
}
}
if (feature.StartsWith("min-", StringComparison.InvariantCultureIgnoreCase))
{
feature = feature.Substring("min-".Length);
if (!IsValidMinMaxFeatureName(feature))
{
Current.RecordError(ErrorType.Parser, forPosition, "Media feature not recognized in min clause, found '" + feature + "'");
throw new StoppedParsingException();
}
return(new MinFeatureMedia(feature, value, forPosition));
}
if (feature.StartsWith("max-", StringComparison.InvariantCultureIgnoreCase))
{
feature = feature.Substring("max-".Length);
if (!IsValidMinMaxFeatureName(feature))
{
Current.RecordError(ErrorType.Parser, forPosition, "Media feature not recognized in max clause, found '" + feature + "'");
throw new StoppedParsingException();
}
return(new MaxFeatureMedia(feature, value, forPosition));
}
return(new EqualFeatureMedia(feature, value, forPosition));
}
private void TestRatioFilter()
{
const double filterValue = 5.0;
RunUI(() =>
{
SkylineWindow.OpenFile(TestFilesDir.GetTestPath("MultiLabel.sky"));
SkylineWindow.ShowDocumentGrid(true);
});
DocumentGridForm documentGrid = FindOpenForm <DocumentGridForm>();
RunUI(() => documentGrid.ChooseView(Resources.SkylineViewContext_GetDocumentGridRowSources_Precursors));
var modifications = SkylineWindow.Document.Settings.PeptideSettings.Modifications;
var isotopeLabel = modifications.InternalStandardTypes.First(
label => label.Name == "heavy 15N");
AddFilter(documentGrid, PropertyPath.Parse("Proteins!*.Peptides!*.Precursors!*.Results!*.Value")
.Property(RatioPropertyDescriptor.MakePropertyName(RatioPropertyDescriptor.RATIO_PREFIX, isotopeLabel)),
FilterOperations.OP_IS_GREATER_THAN_OR_EQUAL,
filterValue.ToString(CultureInfo.CurrentCulture));
RunUI(() =>
{
var colPeptide = documentGrid.FindColumn(PropertyPath.Parse("Peptide"));
var filteredPeptides = Enumerable.Range(0, documentGrid.RowCount).Select(
rowIndex => (Peptide)documentGrid.DataGridView.Rows[rowIndex].Cells[colPeptide.Index].Value)
.ToArray();
CollectionAssert.AreEqual(new [] { "AEVAALAAENK", "AIDYVEATANSHSR" },
filteredPeptides.Select(peptide => peptide.ToString()).ToArray());
var allPeptides = new Peptides(new SkylineDataSchema(SkylineWindow, DataSchemaLocalizer.INVARIANT), new [] { IdentityPath.ROOT });
var ratioIndex = modifications.InternalStandardTypes.IndexOf(isotopeLabel);
Assert.IsTrue(ratioIndex >= 0);
foreach (var peptide in allPeptides.GetItems().OfType <Peptide>())
{
var peptidePath = peptide.IdentityPath;
bool hasMatchingPrecursorResult =
peptide.Precursors.Any(
precursor =>
precursor.Results.Values.Any(
precursorResult =>
RatioValue.GetRatio(precursorResult.ChromInfo.Ratios[ratioIndex]) >= filterValue));
Assert.AreEqual(hasMatchingPrecursorResult, filteredPeptides.Any(filteredPeptide => filteredPeptide.IdentityPath.Equals(peptidePath)));
}
}
);
RunUI(() => documentGrid.ChooseView(Resources.SkylineViewContext_GetDocumentGridRowSources_Precursors));
WaitForConditionUI(() => documentGrid.IsComplete);
Assert.AreEqual(12, documentGrid.RowCount);
{
var quickFilterForm = ShowDialog <QuickFilterForm>(() =>
{
var precursorMzColumn = documentGrid.FindColumn(PropertyPath.Root.Property("Mz"));
documentGrid.QuickFilter(precursorMzColumn);
});
RunUI(() =>
{
quickFilterForm.SetFilterOperation(0, FilterOperations.OP_IS_GREATER_THAN);
quickFilterForm.SetFilterOperand(0, 500.5.ToString(CultureInfo.CurrentCulture));
quickFilterForm.SetFilterOperation(1, FilterOperations.OP_IS_LESS_THAN);
quickFilterForm.SetFilterOperand(1, 600.5.ToString(CultureInfo.CurrentCulture));
});
OkDialog(quickFilterForm, quickFilterForm.OkDialog);
}
WaitForConditionUI(() => documentGrid.IsComplete);
Assert.AreEqual(8, documentGrid.RowCount);
{
var quickFilterForm = ShowDialog <QuickFilterForm>(() =>
{
var precursorMzColumn = documentGrid.FindColumn(PropertyPath.Root.Property("Mz"));
documentGrid.QuickFilter(precursorMzColumn);
});
RunUI(() =>
{
quickFilterForm.SetFilterOperand(0, "invalidnumber");
});
var messageDlg = ShowDialog <AlertDlg>(quickFilterForm.OkDialog);
OkDialog(messageDlg, messageDlg.OkDialog);
OkDialog(quickFilterForm, quickFilterForm.CancelButton.PerformClick);
}
}
public AreaCVRefinementData(SrmDocument document, AreaCVRefinementSettings settings,
CancellationToken token, SrmSettingsChangeMonitor progressMonitor = null)
{
_settings = settings;
if (document == null || !document.Settings.HasResults)
{
return;
}
var replicates = document.MeasuredResults.Chromatograms.Count;
var areas = new List <AreaInfo>(replicates);
var annotations = AnnotationHelper.GetPossibleAnnotations(document, settings.Group).ToArray();
if (!annotations.Any() && settings.Group == null)
{
annotations = new string[] { null }
}
;
_internalData = new List <InternalData>();
var hasHeavyMods = document.Settings.PeptideSettings.Modifications.HasHeavyModifications;
var hasGlobalStandards = document.Settings.HasGlobalStandardArea;
var ms1 = settings.MsLevel == AreaCVMsLevel.precursors;
// Avoid using not-MS1 with a document that is only MS1
if (!ms1 && document.MoleculeTransitions.All(t => t.IsMs1))
{
ms1 = true;
}
double?qvalueCutoff = null;
if (ShouldUseQValues(document))
{
qvalueCutoff = _settings.QValueCutoff;
}
int?minDetections = null;
if (_settings.MinimumDetections != -1)
{
minDetections = _settings.MinimumDetections;
}
MedianInfo medianInfo = null;
int? ratioIndex = null;
if (settings.NormalizeOption.IsRatioToLabel)
{
var isotopeLabelTypeName = (settings.NormalizeOption.NormalizationMethod as NormalizationMethod.RatioToLabel)
?.IsotopeLabelTypeName;
ratioIndex =
document.Settings.PeptideSettings.Modifications.RatioInternalStandardTypes.IndexOf(type =>
type.Name == isotopeLabelTypeName);
}
if (_settings.NormalizeOption.Is(NormalizationMethod.EQUALIZE_MEDIANS))
{
medianInfo = CalculateMedianAreas(document);
}
NormalizationData normalizationData = null;
foreach (var peptideGroup in document.MoleculeGroups)
{
foreach (var peptide in peptideGroup.Molecules)
{
if (progressMonitor != null)
{
progressMonitor.ProcessMolecule(peptide);
}
if (_settings.PointsType == PointsTypePeakArea.decoys != peptide.IsDecoy)
{
continue;
}
CalibrationCurveFitter calibrationCurveFitter = null;
CalibrationCurve calibrationCurve = null;
IEnumerable <TransitionGroupDocNode> transitionGroups;
if (_settings.NormalizeOption == NormalizeOption.CALIBRATED ||
_settings.NormalizeOption == NormalizeOption.DEFAULT)
{
if (!peptide.TransitionGroups.Any())
{
continue;
}
var peptideQuantifier = PeptideQuantifier.GetPeptideQuantifier(() =>
{
return(normalizationData = normalizationData ?? NormalizationData.GetNormalizationData(document, false, null));
}, document.Settings, peptideGroup, peptide);
calibrationCurveFitter = new CalibrationCurveFitter(peptideQuantifier, document.Settings);
transitionGroups = new[] { peptide.TransitionGroups.First() };
if (_settings.NormalizeOption == NormalizeOption.CALIBRATED)
{
calibrationCurve = calibrationCurveFitter.GetCalibrationCurve();
if (calibrationCurve == null)
{
continue;
}
}
}
else
{
transitionGroups = peptide.TransitionGroups;
}
foreach (var transitionGroupDocNode in transitionGroups)
{
foreach (var a in annotations)
{
areas.Clear();
if (!Equals(a, _settings.Annotation) && (_settings.Group == null || _settings.Annotation != null))
{
continue;
}
foreach (var replicateIndex in AnnotationHelper.GetReplicateIndices(document,
_settings.Group, a))
{
if (progressMonitor != null && progressMonitor.IsCanceled())
{
throw new OperationCanceledException();
}
token.ThrowIfCancellationRequested();
var groupChromInfo = transitionGroupDocNode.GetSafeChromInfo(replicateIndex)
.FirstOrDefault(c => c.OptimizationStep == 0);
if (groupChromInfo == null)
{
continue;
}
if (qvalueCutoff.HasValue)
{
if (!(groupChromInfo.QValue.HasValue &&
groupChromInfo.QValue.Value < qvalueCutoff.Value))
{
continue;
}
}
double sumArea, normalizedArea;
if (calibrationCurveFitter != null)
{
double?value;
if (calibrationCurve != null)
{
value = calibrationCurveFitter.GetCalculatedConcentration(calibrationCurve,
replicateIndex);
}
else
{
value = calibrationCurveFitter.GetNormalizedPeakArea(
new CalibrationPoint(replicateIndex, null));
}
if (!value.HasValue)
{
continue;
}
sumArea = value.Value;
normalizedArea = value.Value;
}
else
{
if (!groupChromInfo.Area.HasValue)
{
continue;
}
var index = replicateIndex;
sumArea = transitionGroupDocNode.Transitions.Where(t =>
{
if (ms1 != t.IsMs1 || !t.ExplicitQuantitative)
{
return(false);
}
var chromInfo = t.GetSafeChromInfo(index)
.FirstOrDefault(c => c.OptimizationStep == 0);
if (chromInfo == null)
{
return(false);
}
if (_settings.Transitions == AreaCVTransitions.best)
{
return(chromInfo.RankByLevel == 1);
}
if (_settings.Transitions == AreaCVTransitions.all)
{
return(true);
}
return(chromInfo.RankByLevel <= _settings.CountTransitions);
// ReSharper disable once PossibleNullReferenceException
}).Sum(t => (double)t.GetSafeChromInfo(index)
.FirstOrDefault(c => c.OptimizationStep == 0).Area);
normalizedArea = sumArea;
if (_settings.NormalizeOption.Is(NormalizationMethod.EQUALIZE_MEDIANS))
{
normalizedArea /= medianInfo.Medians[replicateIndex] / medianInfo.MedianMedian;
}
else if (_settings.NormalizeOption.Is(NormalizationMethod.GLOBAL_STANDARDS) &&
hasGlobalStandards)
{
normalizedArea =
NormalizeToGlobalStandard(document, transitionGroupDocNode, replicateIndex,
sumArea);
}
else if (_settings.NormalizeOption.Is(NormalizationMethod.TIC))
{
var denominator = document.Settings.GetTicNormalizationDenominator(
replicateIndex, groupChromInfo.FileId);
if (!denominator.HasValue)
{
continue;
}
normalizedArea /= denominator.Value;
}
else if (hasHeavyMods &&
_settings.NormalizeOption.NormalizationMethod is NormalizationMethod
.RatioToLabel)
{
var ci = transitionGroupDocNode.GetSafeChromInfo(replicateIndex)
.FirstOrDefault(c => c.OptimizationStep == 0);
RatioValue ratioValue = null;
if (ratioIndex.HasValue && ratioIndex.Value >= 0 &&
ratioIndex.Value < ci.Ratios.Count)
{
ratioValue = ci.Ratios[ratioIndex.Value];
}
if (ratioValue == null)
{
continue;
}
normalizedArea = ratioValue.Ratio;
}
}
areas.Add(new AreaInfo(sumArea, normalizedArea));
}
if (qvalueCutoff.HasValue && minDetections.HasValue && areas.Count < minDetections.Value)
{
continue;
}
_settings.AddToInternalData(_internalData, areas, peptideGroup, peptide, transitionGroupDocNode, a);
}
}
}
}
Data = ImmutableList <CVData> .ValueOf(_internalData.GroupBy(i => i, (key, grouped) =>
{
var groupedArray = grouped.ToArray();
return(new CVData(
groupedArray.Select(idata => new PeptideAnnotationPair(idata.PeptideGroup, idata.Peptide, idata.TransitionGroup, idata.Annotation, idata.CV)),
key.CVBucketed, key.Area, groupedArray.Length));
}).OrderBy(d => d.CV));
}
