protected bool Equals(GroupComparisonSelector other)
{
return(Equals(Peptide, other.Peptide) &&
Equals(Protein, other.Protein) &&
Equals(LabelType, other.LabelType) &&
MsLevel == other.MsLevel);
}
public GroupComparisonResult(GroupComparisonSelector selector, int replicateCount, LinearFitResult linearFitResult, IEnumerable <GroupComparer.RunAbundance> runAbundances)
{
Selector = selector;
LinearFitResult = linearFitResult;
ReplicateCount = replicateCount;
RunAbundances = ImmutableList.ValueOf(runAbundances);
}
private GroupComparisonResult CalculateFoldChangeUsingRegression(
GroupComparisonSelector selector, List <RunAbundance> runAbundances)
{
var detailRows = new List <DataRowDetails>();
GetDataRows(selector, detailRows);
if (detailRows.Count == 0)
{
return(null);
}
runAbundances = runAbundances ?? new List <RunAbundance>();
var foldChangeDataRows = detailRows
.Where(row => !double.IsNaN(row.GetLog2Abundance()) && !double.IsInfinity(row.GetLog2Abundance()))
.Select(row => new FoldChangeCalculator.DataRow
{
Abundance = row.GetLog2Abundance(),
Control = row.Control,
Feature = row.IdentityPath,
Run = row.ReplicateIndex,
Subject = row.BioReplicate,
}).ToArray();
FoldChangeDataSet runQuantificationDataSet = FoldChangeCalculator.MakeDataSet(foldChangeDataRows);
var runNumberToReplicateIndex = FoldChangeCalculator.GetUniqueList(foldChangeDataRows.Select(row => row.Run));
var runQuantificationDesignMatrix = DesignMatrix.GetRunQuantificationDesignMatrix(runQuantificationDataSet);
var quantifiedRuns = runQuantificationDesignMatrix.PerformLinearFit(_qrFactorizationCache);
var subjects = new List <int>();
for (int run = 0; run < quantifiedRuns.Count; run++)
{
int iRow = runQuantificationDataSet.Runs.IndexOf(run);
subjects.Add(runQuantificationDataSet.Subjects[iRow]);
var replicateIndex = runNumberToReplicateIndex[run];
var replicateDetails = _replicateIndexes.First(kvp => kvp.Key == replicateIndex).Value;
runAbundances.Add(new RunAbundance
{
ReplicateIndex = replicateIndex,
Control = replicateDetails.IsControl,
BioReplicate = replicateDetails.BioReplicate,
Log2Abundance = quantifiedRuns[run].EstimatedValue
});
}
var abundances = quantifiedRuns.Select(result => result.EstimatedValue).ToArray();
var quantifiedDataSet = new FoldChangeDataSet(
abundances,
Enumerable.Repeat(0, quantifiedRuns.Count).ToArray(),
Enumerable.Range(0, quantifiedRuns.Count).ToArray(),
subjects,
runQuantificationDataSet.SubjectControls);
if (quantifiedDataSet.SubjectControls.Distinct().Count() < 2)
{
return(null);
}
var foldChangeResult = DesignMatrix.GetDesignMatrix(quantifiedDataSet, false).PerformLinearFit(_qrFactorizationCache).First();
return(new GroupComparisonResult(selector, quantifiedRuns.Count, foldChangeResult, runAbundances));
}
public GroupComparisonResult CalculateFoldChange(GroupComparisonSelector selector, List <RunAbundance> runAbundances)
{
if (Equals(ComparisonDef.SummarizationMethod, SummarizationMethod.REGRESSION))
{
return(CalculateFoldChangeUsingRegression(selector, runAbundances));
}
return(CalculateFoldChangeByAveragingTechnicalReplicates(selector, runAbundances));
}
public GroupComparisonResult CalculateFoldChange(GroupComparisonSelector selector, List <RunAbundance> runAbundances)
{
if (Equals(ComparisonDef.SummarizationMethod, SummarizationMethod.REGRESSION))
{
return(CalculateFoldChangeUsingRegression(selector, runAbundances));
}
if (Equals(ComparisonDef.SummarizationMethod, SummarizationMethod.MEDIANPOLISH))
{
return(CalculateFoldChangeWithSummarization(selector, runAbundances, SummarizeDataRowsWithMedianPolish));
}
return(CalculateFoldChangeWithSummarization(selector, runAbundances, SummarizeDataRowsByAveraging));
}
private void GetDataRows(GroupComparisonSelector selector, IList <DataRowDetails> foldChangeDetails)
{
foreach (var replicateEntry in _replicateIndexes)
{
if (!replicateEntry.Value.IsControl &&
!Equals(selector.GroupIdentifier, replicateEntry.Value.GroupIdentifier))
{
continue;
}
foreach (var peptide in selector.ListPeptides())
{
QuantificationSettings quantificationSettings = QuantificationSettings.DEFAULT
.ChangeNormalizationMethod(ComparisonDef.NormalizationMethod)
.ChangeMsLevel(selector.MsLevel);
var peptideQuantifier = new PeptideQuantifier(GetNormalizationData, selector.Protein, peptide,
quantificationSettings)
{
QValueCutoff = ComparisonDef.QValueCutoff
};
if (null != selector.LabelType)
{
peptideQuantifier.MeasuredLabelTypes = ImmutableList.Singleton(selector.LabelType);
}
foreach (var quantityEntry in peptideQuantifier.GetTransitionIntensities(SrmDocument.Settings,
replicateEntry.Key, ComparisonDef.UseZeroForMissingPeaks))
{
var dataRowDetails = new DataRowDetails
{
BioReplicate = replicateEntry.Value.BioReplicate,
Control = replicateEntry.Value.IsControl,
IdentityPath = quantityEntry.Key,
Intensity = Math.Max(1.0, quantityEntry.Value.Intensity),
Denominator = Math.Max(1.0, quantityEntry.Value.Denominator),
ReplicateIndex = replicateEntry.Key,
};
foldChangeDetails.Add(dataRowDetails);
}
}
}
}
private GroupComparisonResult CalculateFoldChangeWithSummarization(GroupComparisonSelector selector,
List <RunAbundance> runAbundances, Func <IList <DataRowDetails>, IList <RunAbundance> > summarizationFunction)
{
var detailRows = new List <DataRowDetails>();
GetDataRows(selector, detailRows);
if (detailRows.Count == 0)
{
return(null);
}
var replicateRows = summarizationFunction(detailRows);
if (replicateRows.Count == 0)
{
return(null);
}
if (null != runAbundances)
{
runAbundances.AddRange(replicateRows);
}
var summarizedRows = replicateRows;
if (replicateRows.Any(row => null != row.BioReplicate))
{
var groupedByBioReplicate = replicateRows.ToLookup(
row => new KeyValuePair <string, bool>(row.BioReplicate, row.Control));
summarizedRows = groupedByBioReplicate.Select(
grouping =>
{
return(new RunAbundance()
{
BioReplicate = grouping.Key.Key,
Control = grouping.Key.Value,
ReplicateIndex = -1,
Log2Abundance = grouping.Average(row => row.Log2Abundance),
});
}).ToList();
}
var quantifiedDataSet = new FoldChangeDataSet(
summarizedRows.Select(row => row.Log2Abundance).ToArray(),
Enumerable.Repeat(0, summarizedRows.Count).ToArray(),
Enumerable.Range(0, summarizedRows.Count).ToArray(),
Enumerable.Range(0, summarizedRows.Count).ToArray(),
summarizedRows.Select(row => row.Control).ToArray());
if (quantifiedDataSet.SubjectControls.Distinct().Count() < 2)
{
return(null);
}
var designMatrix = DesignMatrix.GetDesignMatrix(quantifiedDataSet, false);
var foldChangeResult = designMatrix.PerformLinearFit(_qrFactorizationCache).First();
// Note that because the design matrix has only two columns, this is equivalent to a simple linear
// regression
// var statsAbundances = new Util.Statistics(summarizedRows.Select(row => row.Log2Abundance));
// var statsXValues = new Util.Statistics(summarizedRows.Select(row => row.Control ? 0.0 : 1));
// var slope = statsAbundances.Slope(statsXValues);
return(new GroupComparisonResult(selector, replicateRows.Count, foldChangeResult));
}
public GroupComparisonResult(GroupComparisonSelector selector, int replicateCount, LinearFitResult linearFitResult)
{
Selector = selector;
LinearFitResult = linearFitResult;
ReplicateCount = replicateCount;
}
protected bool Equals(GroupComparisonSelector other)
{
return Equals(Peptide, other.Peptide)
&& Equals(Protein, other.Protein)
&& Equals(LabelType, other.LabelType)
&& MsLevel == other.MsLevel;
}
public GroupComparisonResult(GroupComparisonSelector selector, int replicateCount, LinearFitResult linearFitResult)
{
Selector = selector;
LinearFitResult = linearFitResult;
ReplicateCount = replicateCount;
}
