public AreaCVGraphData(SrmDocument document, AreaCVGraphSettings graphSettings, CancellationToken token = default(CancellationToken))
{
_graphSettings = graphSettings;
if (document == null || !document.Settings.HasResults)
{
IsValid = false;
return;
}
try
{
_refinementData = new AreaCVRefinementData(document, graphSettings, token);
}
catch (Exception)
{
IsValid = false;
return;
}
CalculateStats();
if (IsValid)
{
MedianCV = _refinementData.CalcMedianCV();
}
}
public GraphDataProperties(AreaCVGraphSettings settings)
{
Group = settings.Group;
NormalizeOption = settings.NormalizeOption;
Annotation = settings.Annotation;
MinimumDetections = settings.MinimumDetections;
}
public GraphDataProperties(AreaCVGraphSettings settings)
{
Group = settings.Group;
NormalizationMethod = settings.NormalizationMethod;
RatioIndex = settings.RatioIndex;
Annotation = settings.Annotation;
MinimumDetections = settings.MinimumDetections;
}
public bool IsValidFor(SrmDocument document, AreaCVGraphSettings settings)
{
lock (_cacheInfo)
{
return(_cacheInfo.Document != null && _cacheInfo.Settings != null &&
ReferenceEquals(_cacheInfo.Document.Children, document.Children) &&
AreaCVGraphSettings.CacheEqual(_cacheInfo.Settings, settings));
}
}
public bool TryGet(SrmDocument document, AreaCVGraphSettings settings, Action <AreaCVGraphData> callback, out AreaCVGraphData result)
{
var properties = new GraphDataProperties(settings);
if (!IsValidFor(document, settings))
{
Cancel();
lock (_cacheInfo)
{
_cacheInfo.Clear();
_cacheInfo.Document = document;
_cacheInfo.Settings = settings;
}
// Get a list of all properties that we want to cache data for, except for the data that just got requested
var propertyList = new List <GraphDataProperties>(GetPropertyVariants(settings).Except(new[] { properties }));
_producerConsumer.Add(propertyList, false, false);
}
result = Get(properties);
if (result != null)
{
return(true);
}
lock (_requestLock)
{
if (!properties.Equals((object)_requested))
{
_producerConsumer.Add(properties);
_requested = properties;
_callback = callback;
}
return(false);
}
}
private IEnumerable <GraphDataProperties> GetPropertyVariants(AreaCVGraphSettings graphSettings)
{
SrmDocument document;
lock (_cacheInfo)
{
document = _cacheInfo.Document;
}
var annotationsArray = AnnotationHelper.GetPossibleAnnotations(document, graphSettings.Group);
// Add an entry for All
var annotations = annotationsArray.Concat(new string[] { null }).ToList();
var normalizationMethods = new List <NormalizeOption>(NormalizeOption.AvailableNormalizeOptions(document).Prepend(NormalizeOption.NONE));
// First cache the histograms for the current annotation
if (annotations.Remove(graphSettings.Annotation))
{
annotations.Insert(0, graphSettings.Annotation);
}
foreach (var n in normalizationMethods)
{
if (n.IsRatioToLabel && !document.Settings.PeptideSettings.Modifications.HasHeavyModifications)
{
continue;
}
foreach (var a in annotations)
{
var minDetections = GetMinDetectionsForAnnotation(document, graphSettings, a);
for (var i = 2; i <= minDetections; ++i)
{
yield return(new GraphDataProperties(graphSettings.Group, n, a, i));
}
}
}
}
public static bool CacheEqual(AreaCVGraphSettings a, AreaCVGraphSettings b)
{
return(a.GraphType == b.GraphType && a.Group == b.Group &&
a.PointsType == b.PointsType && (a.QValueCutoff == b.QValueCutoff || double.IsNaN(a.QValueCutoff) && double.IsNaN(b.QValueCutoff)) &&
a.CVCutoff == b.CVCutoff && a.BinWidth == b.BinWidth && a.MsLevel == b.MsLevel && a.Transitions == b.Transitions);
}
public AreaCVGraphData(SrmDocument document, AreaCVGraphSettings graphSettings, CancellationToken?token = null)
{
_graphSettings = graphSettings;
if (document == null || !document.Settings.HasResults)
{
IsValid = false;
return;
}
var annotations = AnnotationHelper.GetPossibleAnnotations(document.Settings, graphSettings.Group, AnnotationDef.AnnotationTarget.replicate);
if (!annotations.Any() && AreaGraphController.GroupByGroup == null)
{
annotations = new string[] { null }
}
;
var data = new List <InternalData>();
double?qvalueCutoff = null;
if (AreaGraphController.ShouldUseQValues(document))
{
qvalueCutoff = _graphSettings.QValueCutoff;
}
var hasHeavyMods = document.Settings.PeptideSettings.Modifications.HasHeavyModifications;
var hasGlobalStandards = document.Settings.HasGlobalStandardArea;
var ms1 = _graphSettings.MsLevel == AreaCVMsLevel.precursors;
var best = _graphSettings.Transitions == AreaCVTransitions.best;
var replicates = document.MeasuredResults.Chromatograms.Count;
var areas = new List <AreaInfo>(replicates);
MedianInfo medianInfo = null;
if (graphSettings.NormalizationMethod == AreaCVNormalizationMethod.medians)
{
medianInfo = CalculateMedianAreas(document);
}
foreach (var peptideGroup in document.MoleculeGroups)
{
foreach (var peptide in peptideGroup.Molecules)
{
foreach (var transitionGroupDocNode in peptide.TransitionGroups)
{
if (graphSettings.PointsType == PointsTypePeakArea.decoys != transitionGroupDocNode.IsDecoy)
{
continue;
}
foreach (var a in annotations)
{
areas.Clear();
if (a != _graphSettings.Annotation && (_graphSettings.Group == null || _graphSettings.Annotation != null))
{
continue;
}
foreach (var i in AnnotationHelper.GetReplicateIndices(document.Settings, _graphSettings.Group, a))
{
if (token.HasValue && token.Value.IsCancellationRequested)
{
IsValid = false;
return;
}
var groupChromInfo = transitionGroupDocNode.GetSafeChromInfo(i)
.FirstOrDefault(c => c.OptimizationStep == 0);
if (qvalueCutoff.HasValue)
{
if (!(groupChromInfo.QValue.HasValue && groupChromInfo.QValue.Value < qvalueCutoff.Value))
{
continue;
}
}
var index = i;
var sumArea = transitionGroupDocNode.Transitions.Where(t =>
{
if (ms1 != t.IsMs1 || !t.ExplicitQuantitative)
{
return(false);
}
var chromInfo = t.GetSafeChromInfo(index).FirstOrDefault(c => c.OptimizationStep == 0);
return(chromInfo != null && (!best || chromInfo.RankByLevel == 1));
// ReSharper disable once PossibleNullReferenceException
}).Sum(t => (double)t.GetSafeChromInfo(index).FirstOrDefault(c => c.OptimizationStep == 0).Area);
if (!groupChromInfo.Area.HasValue)
{
continue;
}
double area = sumArea;
var normalizedArea = area;
if (graphSettings.NormalizationMethod == AreaCVNormalizationMethod.medians)
{
normalizedArea /= medianInfo.Medians[i] / medianInfo.MedianMedian;
}
else if (graphSettings.NormalizationMethod == AreaCVNormalizationMethod.global_standards && hasGlobalStandards)
{
normalizedArea = NormalizeToGlobalStandard(document, transitionGroupDocNode, i, area);
}
else if (graphSettings.NormalizationMethod == AreaCVNormalizationMethod.ratio && hasHeavyMods && graphSettings.RatioIndex >= 0)
{
var ci = transitionGroupDocNode.GetSafeChromInfo(i).FirstOrDefault(c => c.OptimizationStep == 0);
if (ci != null)
{
var ratioValue = ci.GetRatio(_graphSettings.RatioIndex);
if (ratioValue != null)
{
normalizedArea /= ratioValue.Ratio;
}
}
}
areas.Add(new AreaInfo(area, normalizedArea));
}
if (qvalueCutoff.HasValue && areas.Count < graphSettings.MinimumDetections)
{
continue;
}
AddToInternalData(data, areas, peptideGroup, peptide, transitionGroupDocNode, a);
}
}
}
}
Data = ImmutableList <CVData> .ValueOf(data.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));
CalculateStats();
if (IsValid)
{
MedianCV = new Statistics(data.Select(d => d.CV)).Median();
}
}
protected bool Equals(AreaCVGraphSettings other)
{
return(base.Equals(other) && GraphType == other.GraphType && BinWidth.Equals(other.BinWidth));
}
public static bool CacheEqual(AreaCVGraphSettings a, AreaCVGraphSettings b)
{
return(Equals(a, b));
}
private IEnumerable <GraphDataProperties> GetPropertyVariants(AreaCVGraphSettings graphSettings)
{
SrmDocument document;
lock (_cacheInfo)
{
document = _cacheInfo.Document;
}
var annotationsArray = AnnotationHelper.GetPossibleAnnotations(document.Settings,
graphSettings.Group, AnnotationDef.AnnotationTarget.replicate);
// Add an entry for All
var annotations = annotationsArray.Concat(new string[] { null }).ToList();
var normalizationMethods = new List <AreaCVNormalizationMethod> {
AreaCVNormalizationMethod.none, AreaCVNormalizationMethod.medians, AreaCVNormalizationMethod.ratio
};
if (document.Settings.HasGlobalStandardArea)
{
normalizationMethods.Add(AreaCVNormalizationMethod.global_standards);
}
// First cache for current normalization method
if (normalizationMethods.Remove(graphSettings.NormalizationMethod))
{
normalizationMethods.Insert(0, graphSettings.NormalizationMethod);
}
// First cache the histograms for the current annotation
if (annotations.Remove(graphSettings.Annotation))
{
annotations.Insert(0, graphSettings.Annotation);
}
foreach (var n in normalizationMethods)
{
var isRatio = n == AreaCVNormalizationMethod.ratio;
// There can be RatioInternalStandardTypes even though HasHeavyModifications is false
if (isRatio && !document.Settings.PeptideSettings.Modifications.HasHeavyModifications)
{
continue;
}
var ratioIndices = isRatio
? Enumerable.Range(0, document.Settings.PeptideSettings.Modifications.RatioInternalStandardTypes.Count).ToList()
: new List <int> {
-1
};
if (graphSettings.RatioIndex != -1)
{
if (ratioIndices.Remove(graphSettings.RatioIndex))
{
ratioIndices.Insert(0, graphSettings.RatioIndex);
}
}
foreach (var r in ratioIndices)
{
foreach (var a in annotations)
{
var minDetections = GetMinDetectionsForAnnotation(document, graphSettings, a);
for (var i = 2; i <= minDetections; ++i)
{
yield return(new GraphDataProperties(graphSettings.Group, n, r, a, i));
}
}
}
}
}
private static int GetMinDetectionsForAnnotation(SrmDocument document, AreaCVGraphSettings graphSettings, string annotationValue)
{
return(document.Settings.PeptideSettings.Integration.PeakScoringModel.IsTrained && !double.IsNaN(graphSettings.QValueCutoff)
? AnnotationHelper.GetReplicateIndices(document.Settings, graphSettings.Group, annotationValue).Length
: 2);
}
