[Timeout(36000000)] // These can take a long time in code coverage mode
public void TestRunQuantification()
{
var cache = new QrFactorizationCache();
var csvReader = new DsvFileReader(GetTextReader("quant.csv"), ',');
var dataRowsByProtein = ToDataRows(ReadCsvFile(csvReader));
var expectedResultsByProtein = ReadCsvFile(new DsvFileReader(GetTextReader("runquantdata.csv"), ',')).ToLookup(row => row["Protein"]);
foreach (var entry in dataRowsByProtein)
{
var expectedResultsByRun = expectedResultsByProtein[entry.Key].ToLookup(row => row["RUN"]);
FoldChangeDataSet dataSet = FoldChangeCalculator.MakeDataSet(entry.Value);
var designMatrix = DesignMatrix.GetRunQuantificationDesignMatrix(dataSet);
var runNames = FoldChangeCalculator.GetUniqueList(entry.Value.Select(row => row.Run));
var results = designMatrix.PerformLinearFit(cache);
for (int i = 0; i < dataSet.RunCount; i++)
{
string message = string.Format("Protein:{0} Run:{1}", entry.Key, runNames[i]);
var expectedRow = expectedResultsByRun[runNames[i]].FirstOrDefault();
Assert.IsNotNull(expectedRow);
Assert.AreEqual(double.Parse(expectedRow["LogIntensities"], CultureInfo.InvariantCulture), results[i].EstimatedValue, .000001, message);
Assert.AreEqual(int.Parse(expectedRow["NumFeature"], CultureInfo.InvariantCulture), dataSet.FeatureCount, message);
Assert.AreEqual(int.Parse(expectedRow["NumPeaks"], CultureInfo.InvariantCulture), dataSet.GetFeatureCountForRun(i), message);
}
}
}
private void TestGroupComparison(TextReader textReader, bool includeInteraction, IDictionary <string, LinearFitResult> expectedResults)
{
var csvReader = new DsvFileReader(textReader, ',');
var dataRowsByProtein = ToDataRows(ReadCsvFile(csvReader));
Assert.AreNotEqual(0, dataRowsByProtein.Count);
var cache = new QrFactorizationCache();
foreach (var entry in dataRowsByProtein)
{
FoldChangeDataSet dataSet = FoldChangeCalculator.MakeDataSet(entry.Value);
var designMatrix = DesignMatrix.GetDesignMatrix(dataSet, includeInteraction);
var foldChange = designMatrix.PerformLinearFit(cache).First();
LinearFitResult expectedResult = null;
if (null != expectedResults)
{
Assert.IsTrue(expectedResults.TryGetValue(entry.Key, out expectedResult));
}
if (null != expectedResult)
{
Assert.AreEqual(expectedResult.EstimatedValue, foldChange.EstimatedValue, 1E-6);
Assert.AreEqual(expectedResult.DegreesOfFreedom, foldChange.DegreesOfFreedom);
Assert.AreEqual(expectedResult.StandardError, foldChange.StandardError, 1E-6);
Assert.AreEqual(expectedResult.TValue, foldChange.TValue, 1E-6);
Assert.AreEqual(expectedResult.PValue, foldChange.PValue, 1E-6);
}
}
}
public static LinearModel CreateModel(QrFactorizationCache cache, Matrix <double> designMatrix, Matrix <double> contrastValues, double tolerance)
{
if (contrastValues.ColumnCount != designMatrix.ColumnCount)
{
throw new ArgumentException("Wrong number of columns"); // Not L10N
}
var cacheEntry = cache.GetQrFactorization(designMatrix, tolerance);
return(new LinearModel(designMatrix, contrastValues, cacheEntry));
}
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);
}
[Timeout(36000000)] // These can take a long time in code coverage mode
public void TestGroupComparisonWithRunQuantification()
{
var csvReader = new DsvFileReader(GetTextReader("quant.csv"), ',');
var dataRowsByProtein = ToDataRows(ReadCsvFile(csvReader));
var expectedResultsByProtein = ReadCsvFile(new DsvFileReader(GetTextReader("result_newtesting_v2.csv"), ','))
.ToDictionary(row => row["Protein"]);
var cache = new QrFactorizationCache();
foreach (var entry in dataRowsByProtein)
{
FoldChangeDataSet dataSet = FoldChangeCalculator.MakeDataSet(entry.Value);
var quantifiedRuns = DesignMatrix.GetRunQuantificationDesignMatrix(dataSet).PerformLinearFit(cache);
var subjects = new List <int>();
for (int run = 0; run < quantifiedRuns.Count; run++)
{
int iRow = dataSet.Runs.IndexOf(run);
subjects.Add(dataSet.Subjects[iRow]);
}
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,
dataSet.SubjectControls);
var foldChangeResult = DesignMatrix.GetDesignMatrix(quantifiedDataSet, false).PerformLinearFit(cache).First();
var expectedResult = expectedResultsByProtein[entry.Key];
string message = entry.Key;
Assert.AreEqual(double.Parse(expectedResult["logFC"], CultureInfo.InvariantCulture), foldChangeResult.EstimatedValue, 1E-6, message);
Assert.AreEqual(double.Parse(expectedResult["SE"], CultureInfo.InvariantCulture), foldChangeResult.StandardError, 1E-6, message);
Assert.AreEqual(int.Parse(expectedResult["DF"], CultureInfo.InvariantCulture), foldChangeResult.DegreesOfFreedom, message);
if (Math.Abs(foldChangeResult.EstimatedValue) > 1E-8)
{
Assert.AreEqual(double.Parse(expectedResult["pvalue"], CultureInfo.InvariantCulture), foldChangeResult.PValue, 1E-6, message);
Assert.AreEqual(double.Parse(expectedResult["Tvalue"], CultureInfo.InvariantCulture), foldChangeResult.TValue, 1E-6, message);
}
}
}
public IList <LinearFitResult> PerformLinearFit(QrFactorizationCache cache)
{
var linearModel = LinearModel.CreateModel(cache, DenseMatrix.OfColumnArrays(_matrixColumns), DenseMatrix.OfColumnArrays(_contrastValues), 1E-7);
return(linearModel.Fit(DataSet.Abundances.ToArray()));
}
