public GroupIdentifier GetGroupIdentifier(AnnotationCalculator annotationCalculator, ChromatogramSet chromatogramSet)
{
AnnotationDef annotationDef =
annotationCalculator.SrmDocument.Settings.DataSettings.AnnotationDefs.FirstOrDefault(a => a.Name == ControlAnnotation);
if (annotationDef == null)
{
return(default(GroupIdentifier));
}
return(GroupIdentifier.MakeGroupIdentifier(annotationCalculator.GetReplicateAnnotation(annotationDef, chromatogramSet)));
}
/// <summary>
/// Gets possible values for an annotation.
/// </summary>
public static IEnumerable <object> GetPossibleAnnotations(SrmDocument document, ReplicateValue replicateValue)
{
if (!document.Settings.HasResults || null == replicateValue)
{
return(new object[0]);
}
var annotationCalculator = new AnnotationCalculator(document);
return(document.Settings.MeasuredResults.Chromatograms
.Select(chromSet => replicateValue.GetValue(annotationCalculator, chromSet)).Distinct()
.OrderBy(x => x, CollectionUtil.ColumnValueComparer));
}
private static bool HasDistinctValues(AnnotationCalculator annotationCalculator, ReplicateValue replicateValue)
{
var settings = annotationCalculator.SrmDocument.Settings;
if (!settings.HasResults)
{
return(false);
}
var values = settings.MeasuredResults.Chromatograms.Select(chromSet => replicateValue.GetValue(annotationCalculator, chromSet)).Distinct().ToArray();
return(values.Length > 1);
}
/// <summary>
/// Gets replicate indices for a specific grouping annotation and value.
/// </summary>
public static int[] GetReplicateIndices(SrmDocument document, ReplicateValue group, object groupValue)
{
var defaultResult = Enumerable.Range(0, document.Settings.MeasuredResults.Chromatograms.Count).ToArray();
if (group == null)
{
return(defaultResult);
}
var annotationCalculator = new AnnotationCalculator(document);
return(defaultResult.Where(i => Equals(groupValue,
group.GetValue(annotationCalculator, document.Settings.MeasuredResults.Chromatograms[i]))).ToArray());
}
public GroupComparer(GroupComparisonDef comparisonDef, SrmDocument document, QrFactorizationCache qrFactorizationCache)
{
SrmDocument = document;
ComparisonDef = comparisonDef;
var annotationCalculator = new AnnotationCalculator(document);
_qrFactorizationCache = qrFactorizationCache;
List <KeyValuePair <int, ReplicateDetails> > replicateIndexes = new List <KeyValuePair <int, ReplicateDetails> >();
var controlGroupIdentifier = ComparisonDef.GetControlGroupIdentifier(SrmDocument.Settings);
if (SrmDocument.Settings.HasResults)
{
var chromatograms = SrmDocument.Settings.MeasuredResults.Chromatograms;
for (int i = 0; i < chromatograms.Count; i++)
{
var chromatogramSet = chromatograms[i];
ReplicateDetails replicateDetails = new ReplicateDetails()
{
GroupIdentifier = comparisonDef.GetGroupIdentifier(annotationCalculator, chromatogramSet)
};
if (Equals(controlGroupIdentifier, replicateDetails.GroupIdentifier))
{
replicateDetails.IsControl = true;
}
else
{
if (!string.IsNullOrEmpty(ComparisonDef.CaseValue))
{
var annotationValue = chromatogramSet.Annotations.GetAnnotation(ComparisonDef.ControlAnnotation);
if (!Equals(annotationValue, ComparisonDef.CaseValue))
{
continue;
}
}
}
if (null != ComparisonDef.IdentityAnnotation)
{
replicateDetails.BioReplicate =
chromatogramSet.Annotations.GetAnnotation(ComparisonDef.IdentityAnnotation);
}
replicateIndexes.Add(new KeyValuePair <int, ReplicateDetails>(i, replicateDetails));
}
}
_replicateIndexes = ImmutableList.ValueOf(replicateIndexes);
IsValid = _replicateIndexes.Any(keyValuePair => keyValuePair.Value.IsControl) &&
_replicateIndexes.Any(keyValuePair => !keyValuePair.Value.IsControl);
}
public static IEnumerable <ReplicateValue> GetGroupableReplicateValues(SrmDocument document)
{
var settings = document.Settings;
var annotationCalculator = new AnnotationCalculator(document);
var withDistinctValues = GetAllReplicateValues(settings)
.Where(replicateValue => replicateValue is Annotation || HasDistinctValues(annotationCalculator, replicateValue)).ToArray();
var lookupByTitle = withDistinctValues.ToLookup(replicateValue => replicateValue.Title);
foreach (var replicateValue in withDistinctValues)
{
if (lookupByTitle[replicateValue.Title].Skip(1).Any())
{
yield return(replicateValue.ChangeDisambiguateTitle(true));
}
else
{
yield return(replicateValue);
}
}
}
public static SrmDocument ApplyPeak(SrmDocument doc, PeptideTreeNode nodePepTree, ref TransitionGroupDocNode nodeTranGroup,
int resultsIndex, ChromFileInfoId resultsFile, bool subsequent, ReplicateValue groupBy, object groupByValue, ILongWaitBroker longWaitBroker)
{
nodeTranGroup = nodeTranGroup ?? PickTransitionGroup(doc, nodePepTree, resultsIndex);
GetReferenceData(doc, nodePepTree.DocNode, nodeTranGroup, resultsIndex, resultsFile, out var referenceTarget, out var referenceMatchData, out var runTime);
var annotationCalculator = new AnnotationCalculator(doc);
var chromatograms = doc.Settings.MeasuredResults.Chromatograms;
for (var i = 0; i < chromatograms.Count; i++)
{
var chromSet = chromatograms[i];
if (groupBy != null)
{
if (!Equals(groupByValue, groupBy.GetValue(annotationCalculator, chromSet)))
{
continue;
}
}
for (var j = 0; j < chromSet.MSDataFileInfos.Count; j++)
{
var fileInfo = chromSet.MSDataFileInfos[j];
if ((i == resultsIndex && (resultsFile == null || ReferenceEquals(resultsFile, fileInfo.FileId))) ||
(subsequent && runTime != null && fileInfo.RunStartTime < runTime))
{
continue;
}
var bestMatch = GetPeakMatch(doc, chromSet, fileInfo, nodeTranGroup, referenceTarget, referenceMatchData);
if (bestMatch != null)
{
doc = bestMatch.ChangePeak(doc, nodePepTree, nodeTranGroup, chromSet.Name, fileInfo.FilePath);
}
}
longWaitBroker.SetProgressCheckCancel(i + 1, chromatograms.Count);
}
return(doc);
}
protected virtual IEnumerable <ReplicateGroup> GetReplicateGroups(IEnumerable <int> replicateIndexes)
{
if (_document.Settings.MeasuredResults == null)
{
return(new ReplicateGroup[0]); // Likely user removed all results while Mass Errors window was open
}
var annotationCalculator = new AnnotationCalculator(_document);
var chromatograms = _document.Settings.MeasuredResults.Chromatograms;
var result = new List <ReplicateGroup>();
if (ReplicateGroupOp.GroupByValue == null)
{
foreach (var index in replicateIndexes)
{
var chromatogram = _document.MeasuredResults.Chromatograms[index];
result.AddRange(chromatogram.MSDataFileInfos.Select(fileInfo => new ReplicateGroup(chromatogram.Name, ReplicateIndexSet.Singleton(index), fileInfo)));
}
var query = result.OrderBy(g => 0);
if (!string.IsNullOrEmpty(OrderByReplicateAnnotation))
{
var orderByReplicateValue = ReplicateValue.FromPersistedString(_document.Settings, OrderByReplicateAnnotation);
if (orderByReplicateValue != null)
{
query = result.OrderBy(
g => orderByReplicateValue.GetValue(annotationCalculator,
chromatograms[g.ReplicateIndexes.First()]), CollectionUtil.ColumnValueComparer);
}
}
if (ReplicateOrder == SummaryReplicateOrder.document)
{
result = new List <ReplicateGroup>(query.ThenBy(g => g.ReplicateIndexes.ToArray(),
Comparer <int[]> .Create((a, b) =>
{
for (var i = 0; i < Math.Min(a.Length, b.Length); ++i)
{
if (a[i] != b[i])
{
return(a[i].CompareTo(b[i]));
}
}
return(a.Length.CompareTo(b.Length));
})).ThenBy(g => g.FileInfo.FileIndex));
}
else if (ReplicateOrder == SummaryReplicateOrder.time)
{
result = new List <ReplicateGroup>(query
.ThenBy(g => g.FileInfo.RunStartTime,
Comparer <DateTime?> .Create(
(a, b) => (a ?? DateTime.MaxValue).CompareTo(
b ?? DateTime.MaxValue))).ThenBy(g => g.FileInfo.FileIndex).ToList());
}
}
else
{
var lookup = replicateIndexes.ToLookup(replicateIndex =>
ReplicateGroupOp.GroupByValue.GetValue(annotationCalculator, chromatograms[replicateIndex]));
var keys = lookup.Select(grouping => grouping.Key).ToList();
if (keys.Count > 2)
{
// If there are more than 2 groups then exclude replicates with blank annotation values.
keys.Remove(null);
}
keys.Sort(CollectionUtil.ColumnValueComparer);
// ReSharper disable AssignNullToNotNullAttribute
foreach (var key in keys)
{
result.Add(new ReplicateGroup(key?.ToString() ?? string.Empty, ReplicateIndexSet.OfValues(lookup[key])));
}
// ReSharper restore AssignNullToNotNullAttribute
}
return(result.Distinct());
}
public override object GetValue(AnnotationCalculator annotationCalculator, ChromatogramSet chromatogramSet)
{
return(annotationCalculator.GetReplicateAnnotation(AnnotationDef, chromatogramSet));
}
public abstract object GetValue(AnnotationCalculator annotationCalculator, ChromatogramSet chromatogramSet);
public override object GetValue(AnnotationCalculator annotationCalculator, ChromatogramSet node)
{
return(_getValueFunc(node));
}
private void comboAppliesTo_SelectedIndexChanged(object sender, EventArgs e)
{
if (comboAppliesTo.SelectedIndex < 0)
{
availableFieldsTree1.RootColumn = NullRootColumn;
}
var annotationTargetItem = (AnnotationTargetItem)comboAppliesTo.Items[comboAppliesTo.SelectedIndex];
AnnotationTargets = AnnotationDef.AnnotationTargetSet.Singleton(annotationTargetItem.AnnotationTarget);
availableFieldsTree1.RootColumn = ColumnDescriptor.RootColumn(_dataSchema, AnnotationCalculator.RowTypeFromAnnotationTarget(annotationTargetItem.AnnotationTarget), UiModes.FromDocumentType(ModeUI));
}
