public bool CalcRegressionWith(IRetentionTimeProvider retentionTimes, IEnumerable <DbIrtPeptide> standardPeptideList, DbIrtPeptide[] items)
{
if (items.Any())
{
// Attempt to get a regression based on shared peptides
var calculator = new CurrentCalculator(standardPeptideList, items);
var peptidesTimes = retentionTimes.PeptideRetentionTimes.ToArray();
var regression = RetentionTimeRegression.FindThreshold(RCalcIrt.MIN_IRT_TO_TIME_CORRELATION,
RetentionTimeRegression.ThresholdPrecision,
peptidesTimes,
new MeasuredRetentionTime[0],
peptidesTimes, null,
calculator,
RegressionMethodRT.linear,
() => false);
var startingCount = peptidesTimes.Length;
var regressionCount = regression != null ? regression.PeptideTimes.Count : 0;
if (regression != null && RCalcIrt.IsAcceptableStandardCount(startingCount, regressionCount))
{
// Finally must recalculate the regression, because it is transposed from what
// we want.
var statTimes = new Statistics(regression.PeptideTimes.Select(pt => pt.RetentionTime));
var statIrts = new Statistics(regression.PeptideTimes.Select(pt =>
calculator.ScoreSequence(pt.PeptideSequence) ?? calculator.UnknownScore));
RegressionRefined = new RegressionLine(statIrts.Slope(statTimes), statIrts.Intercept(statTimes));
RegressionSuccess = true;
return(true);
}
}
return(false);
}
private static void AddRetentionTimesToDict(IRetentionTimeProvider retentionTimes,
IRegressionFunction regressionLine,
IDictionary <Target, IrtPeptideAverages> dictPeptideAverages,
IEnumerable <DbIrtPeptide> standardPeptideList)
{
var setStandards = new TargetMap <bool>(standardPeptideList.Select(peptide => new KeyValuePair <Target, bool>(peptide.Target, true)));
foreach (var pepTime in retentionTimes.PeptideRetentionTimes.Where(p => !setStandards.ContainsKey(p.PeptideSequence)))
{
var peptideModSeq = pepTime.PeptideSequence;
var timeSource = retentionTimes.GetTimeSource(peptideModSeq);
var irt = regressionLine.GetY(pepTime.RetentionTime);
if (!dictPeptideAverages.TryGetValue(peptideModSeq, out var pepAverage))
{
dictPeptideAverages.Add(peptideModSeq, new IrtPeptideAverages(peptideModSeq, irt, timeSource));
}
else
{
pepAverage.AddIrt(irt);
}
}
}
public RetentionTimeProviderData(IRetentionTimeProvider retentionTimes, IEnumerable <DbIrtPeptide> standardPeptides)
{
RetentionTimeProvider = retentionTimes;
Peptides = standardPeptides.Select(standardPeptide => new Peptide(standardPeptide.ModifiedTarget,
retentionTimes.GetRetentionTime(standardPeptide.ModifiedTarget), standardPeptide.Irt)).ToList();
Peptides.Sort((x, y) => x.Irt.CompareTo(y.Irt));
if (!FilteredPeptides.Any())
{
Regression = null;
RegressionRefined = null;
RegressionSuccess = false;
}
var filteredRt = FilteredPeptides.Select(pep => pep.RetentionTime.Value).ToList();
var filteredIrt = FilteredPeptides.Select(pep => pep.Irt).ToList();
var statTimes = new Statistics(filteredRt);
var statIrts = new Statistics(filteredIrt);
Regression = new RegressionLine(statIrts.Slope(statTimes), statIrts.Intercept(statTimes));
var removed = new List <Tuple <double, double> >();
RegressionSuccess = RCalcIrt.TryGetRegressionLine(filteredRt, filteredIrt, MinPoints, out _regressionRefined, removed);
foreach (var remove in removed)
{
for (var i = 0; i < Peptides.Count; i++)
{
var peptide = Peptides[i];
if (peptide.RetentionTime.Equals(remove.Item1) && peptide.Irt.Equals(remove.Item2))
{
Peptides[i] = new Peptide(peptide, true);
}
}
}
}
public RetentionTimeProviderData(IRetentionTimeProvider retentionTimes, IEnumerable <DbIrtPeptide> standardPeptides)
{
RetentionTimeProvider = retentionTimes;
// Attempt to get regression based on standards
var listPeptides = new List <Target>();
var listTimes = new List <double>();
var listIrts = new List <double>();
foreach (var standardPeptide in standardPeptides)
{
listPeptides.Add(standardPeptide.ModifiedTarget);
listTimes.Add(retentionTimes.GetRetentionTime(standardPeptide.ModifiedTarget) ?? double.MaxValue);
listIrts.Add(standardPeptide.Irt);
}
var arrayTimes = listTimes.ToArray();
// var libraryTimes = retentionTimes as LibraryRetentionTimes;
// if (libraryTimes != null)
// Trace.WriteLine(libraryTimes.Name);
// Trace.WriteLine(string.Format("times = {0}", string.Join(", ", arrayTimes.Select(t => string.Format("{0:F02}", t)))));
Peptides = listPeptides.ToArray();
Times = arrayTimes;
Irts = listIrts.ToArray();
MissingIndices = new HashSet <int>();
for (var i = 0; i < Times.Length; i++)
{
if (Times[i] == double.MaxValue)
{
MissingIndices.Add(i);
}
}
TimesFiltered = Times.Where((v, i) => !MissingIndices.Contains(i)).ToArray();
IrtsFiltered = Irts.Where((v, i) => !MissingIndices.Contains(i)).ToArray();
OutlierIndices = new HashSet <int>();
if (TimesFiltered.Any())
{
var statTimes = new Statistics(TimesFiltered);
var statIrts = new Statistics(IrtsFiltered);
Regression = new RegressionLine(statIrts.Slope(statTimes), statIrts.Intercept(statTimes));
var removed = new List <Tuple <double, double> >();
RegressionSuccess = RCalcIrt.TryGetRegressionLine(TimesFiltered.ToList(), IrtsFiltered.ToList(), MinPoints, out _regressionRefined, removed);
foreach (var remove in removed)
{
for (var i = 0; i < Times.Length && i < Irts.Length; i++)
{
if (Times[i] == remove.Item1 && Irts[i] == remove.Item2)
{
OutlierIndices.Add(i);
}
}
}
}
else
{
Regression = null;
RegressionRefined = null;
RegressionSuccess = false;
}
}
public RetentionTimeProviderData(IrtRegressionType regressionType, IRetentionTimeProvider retentionTimes,
IReadOnlyList <DbIrtPeptide> standardPeptides, IReadOnlyList <DbIrtPeptide> heavyStandardPeptides)
{
RetentionTimeProvider = retentionTimes;
Peptides = new List <Peptide>(standardPeptides.Count);
for (var i = 0; i < standardPeptides.Count; i++)
{
var heavy = heavyStandardPeptides[i] != null;
var standard = heavy ? heavyStandardPeptides[i] : standardPeptides[i];
var rt = retentionTimes.GetRetentionTime(standard.ModifiedTarget);
if (!rt.HasValue && heavy)
{
standard = standardPeptides[i];
rt = retentionTimes.GetRetentionTime(standard.ModifiedTarget);
}
Peptides.Add(new Peptide(standard.ModifiedTarget, rt, standard.Irt));
}
Peptides.Sort((x, y) => x.Irt.CompareTo(y.Irt));
if (!FilteredPeptides.Any())
{
Regression = null;
RegressionRefined = null;
RegressionSuccess = false;
}
var filteredRt = FilteredPeptides.Select(pep => pep.RetentionTime.Value).ToList();
var filteredIrt = FilteredPeptides.Select(pep => pep.Irt).ToList();
var removed = new List <Tuple <double, double> >();
if (ReferenceEquals(regressionType, IrtRegressionType.LINEAR))
{
Regression = new RegressionLine(filteredRt.ToArray(), filteredIrt.ToArray());
}
else if (ReferenceEquals(regressionType, IrtRegressionType.LOGARITHMIC))
{
Regression = new LogRegression(filteredRt, filteredIrt);
}
else if (ReferenceEquals(regressionType, IrtRegressionType.LOWESS))
{
Regression = new LoessRegression(filteredRt.ToArray(), filteredIrt.ToArray());
}
else
{
throw new ArgumentException();
}
IIrtRegression regressionRefined;
if (IrtRegression.Accept(Regression, MinPoints))
{
regressionRefined = Regression;
Regression = null;
RegressionSuccess = true;
}
else
{
RegressionSuccess = IrtRegression.TryGet(Regression, filteredRt, filteredIrt, MinPoints, out regressionRefined, removed);
}
RegressionRefined = regressionRefined;
foreach (var remove in removed)
{
for (var i = 0; i < Peptides.Count; i++)
{
var peptide = Peptides[i];
if (peptide.RetentionTime.Equals(remove.Item1) && peptide.Irt.Equals(remove.Item2))
{
Peptides[i] = new Peptide(peptide, true);
}
}
}
}
