protected CalibrationCurve AddRSquared(CalibrationCurve curve, IList <WeightedPoint> points)
{
List <double> yValues = new List <double>();
List <double> residuals = new List <double>();
foreach (var point in points)
{
double?yFitted = curve.GetY(point.X);
if (!yFitted.HasValue)
{
continue;
}
yValues.Add(point.Y);
residuals.Add(point.Y - yFitted.Value);
}
if (!residuals.Any())
{
return(curve);
}
double yMean = yValues.Average();
double totalSumOfSquares = yValues.Sum(y => (y - yMean) * (y - yMean));
double sumOfSquaresOfResiduals = residuals.Sum(r => r * r);
double rSquared = 1 - sumOfSquaresOfResiduals / totalSumOfSquares;
return(curve.ChangeRSquared(rSquared));
}
public CalibrationCurve GetCalibrationCurve()
{
if (RegressionFit.NONE.Equals(QuantificationSettings.RegressionFit))
{
if (HasInternalStandardConcentration())
{
return(CalibrationCurve.NO_EXTERNAL_STANDARDS
.ChangeSlope(1 / PeptideQuantifier.PeptideDocNode.InternalStandardConcentration.GetValueOrDefault(1.0)));
}
return(CalibrationCurve.NO_EXTERNAL_STANDARDS);
}
List <WeightedPoint> weightedPoints = new List <WeightedPoint>();
foreach (var replicateIndex in GetValidStandardReplicates())
{
double?intensity = GetYValue(replicateIndex);
if (!intensity.HasValue)
{
continue;
}
double x = GetSpecifiedXValue(replicateIndex).Value;
double weight = QuantificationSettings.RegressionWeighting.GetWeighting(x, intensity.Value);
WeightedPoint weightedPoint = new WeightedPoint(x, intensity.Value, weight);
weightedPoints.Add(weightedPoint);
}
if (weightedPoints.Count == 0)
{
return(new CalibrationCurve()
.ChangeErrorMessage(QuantificationStrings.CalibrationCurveFitter_GetCalibrationCurve_All_of_the_external_standards_are_missing_one_or_more_peaks_));
}
CalibrationCurve calibrationCurve = QuantificationSettings.RegressionFit.Fit(weightedPoints);
return(calibrationCurve);
}
public PrecursorQuantificationResult GetPrecursorQuantificationResult(int replicateIndex, TransitionGroupDocNode transitionGroupDocNode)
{
PrecursorQuantificationResult result = null;
if (IsotopologResponseCurve)
{
result = new PrecursorQuantificationResult();
var calibrationPoint = new CalibrationPoint(replicateIndex, transitionGroupDocNode.LabelType);
CalibrationCurve calibrationCurve = GetCalibrationCurve();
result = (PrecursorQuantificationResult)result.ChangeNormalizedArea(GetNormalizedPeakArea(calibrationPoint));
if (HasExternalStandards() || HasInternalStandardConcentration())
{
double?calculatedConcentration = GetCalculatedConcentration(calibrationCurve, calibrationPoint);
result = (PrecursorQuantificationResult)result.ChangeCalculatedConcentration(calculatedConcentration);
double?expectedConcentration = transitionGroupDocNode.PrecursorConcentration;
result = (PrecursorQuantificationResult)result.ChangeAccuracy(calculatedConcentration / expectedConcentration);
result = (PrecursorQuantificationResult)result.ChangeUnits(QuantificationSettings.Units);
}
}
var targetIonRatio = GetTargetIonRatio(transitionGroupDocNode);
var ionRatio = PeptideQuantifier.GetQualitativeIonRatio(SrmSettings, transitionGroupDocNode, replicateIndex);
if (targetIonRatio.HasValue || ionRatio.HasValue)
{
result = result ?? new PrecursorQuantificationResult();
var status = ValueStatus.GetStatus(ionRatio, GetTargetIonRatio(transitionGroupDocNode),
SrmSettings.PeptideSettings.Quantification.QualitativeIonRatioThreshold / 100);
result = result.ChangeIonRatio(targetIonRatio, ionRatio, status);
}
return(result);
}
public double?GetLimitOfQuantification(CalibrationCurve calibrationCurve)
{
if (!QuantificationSettings.MaxLoqBias.HasValue && !QuantificationSettings.MaxLoqCv.HasValue)
{
return(null);
}
var concentrationReplicateLookup = GetStandardConcentrations().ToLookup(entry => entry.Value, entry => entry.Key);
foreach (var concentrationReplicate in concentrationReplicateLookup.OrderBy(grouping => grouping.Key))
{
var peakAreas = new List <double>();
foreach (var replicateIndex in concentrationReplicate)
{
double?peakArea = GetNormalizedPeakArea(replicateIndex);
if (peakArea.HasValue)
{
peakAreas.Add(peakArea.Value);
}
}
if (QuantificationSettings.MaxLoqCv.HasValue)
{
double cv = peakAreas.StandardDeviation() / peakAreas.Mean();
if (double.IsNaN(cv) || double.IsInfinity(cv))
{
continue;
}
if (cv * 100 > QuantificationSettings.MaxLoqCv)
{
continue;
}
}
if (QuantificationSettings.MaxLoqBias.HasValue)
{
if (calibrationCurve == null)
{
continue;
}
double meanPeakArea = peakAreas.Mean();
double?backCalculatedConcentration =
GetConcentrationFromXValue(calibrationCurve.GetFittedX(meanPeakArea));
if (!backCalculatedConcentration.HasValue)
{
continue;
}
double bias = (concentrationReplicate.Key - backCalculatedConcentration.Value) /
concentrationReplicate.Key;
if (double.IsNaN(bias) || double.IsInfinity(bias))
{
continue;
}
if (Math.Abs(bias * 10) > QuantificationSettings.MaxLoqBias.Value)
{
continue;
}
}
return(concentrationReplicate.Key);
}
return(null);
}
public double?GetCalculatedConcentration(CalibrationCurve calibrationCurve, int replicateIndex)
{
if (!HasExternalStandards() && !HasInternalStandardConcentration())
{
return(null);
}
return(GetConcentrationFromXValue(GetCalculatedXValue(calibrationCurve, replicateIndex) * GetDilutionFactor(replicateIndex)));
}
public override double?GetY(CalibrationCurve calibrationCurve, double?x)
{
if (calibrationCurve.TurningPoint.HasValue && x < calibrationCurve.TurningPoint)
{
x = calibrationCurve.TurningPoint;
}
return(base.GetY(calibrationCurve, x));
}
public override double?GetX(CalibrationCurve calibrationCurve, double?y)
{
double?x = GetFittedX(calibrationCurve, y);
if (x.HasValue && calibrationCurve.TurningPoint.HasValue && x < calibrationCurve.TurningPoint)
{
return(null);
}
return(x);
}
public override double?GetY(CalibrationCurve calibrationCurve, double?x)
{
if (x.HasValue)
{
var y = base.GetY(calibrationCurve, Math.Log(x.Value));
if (y.HasValue)
{
return(Math.Exp(y.Value));
}
}
return(null);
}
public override double?GetFittedX(CalibrationCurve calibrationCurve, double?y)
{
if (y.HasValue)
{
var x = base.GetFittedX(calibrationCurve, Math.Log(y.Value));
if (x.HasValue)
{
return(Math.Exp(x.Value));
}
}
return(null);
}
public double?GetCalculatedConcentration(CalibrationCurve calibrationCurve, int replicateIndex)
{
if (!HasExternalStandards() && !HasInternalStandardConcentration())
{
return(null);
}
double?xValue = GetCalculatedXValue(calibrationCurve, replicateIndex);
if (HasExternalStandards() && HasInternalStandardConcentration())
{
return(xValue * PeptideQuantifier.PeptideDocNode.InternalStandardConcentration);
}
return(xValue);
}
public static CalibrationCurve LinearFit(IList<WeightedPoint> points)
{
CalibrationCurve calibrationCurve = new CalibrationCurve().ChangePointCount(points.Count);
try
{
double[] values = WeightedRegression.Weighted(points.Select(p => new Tuple<double[], double>(new[] {p.X}, p.Y)),
points.Select(p => p.Weight).ToArray(), true);
calibrationCurve = calibrationCurve.ChangeSlope(values[1]).ChangeIntercept(values[0]);
}
catch (Exception ex)
{
calibrationCurve = calibrationCurve.ChangeErrorMessage(ex.Message);
}
return calibrationCurve;
}
public CalibrationCurve Fit(IList <WeightedPoint> points)
{
try
{
CalibrationCurve curve = _fitFunc(points);
if (curve != null)
{
curve = AddRSquared(curve, points);
}
return(curve);
}
catch (Exception e)
{
return(new CalibrationCurve().ChangeErrorMessage(e.Message));
}
}
public QuantificationResult GetQuantificationResult(int replicateIndex)
{
QuantificationResult result = new QuantificationResult();
CalibrationCurve calibrationCurve = GetCalibrationCurve();
result = result.ChangeNormalizedArea(GetNormalizedPeakArea(replicateIndex));
if (HasExternalStandards() || HasInternalStandardConcentration())
{
double?calculatedConcentration = GetCalculatedConcentration(calibrationCurve, replicateIndex);
result = result.ChangeCalculatedConcentration(calculatedConcentration);
double?expectedConcentration = GetPeptideConcentration(GetChromatogramSet(replicateIndex));
result = result.ChangeAccuracy(calculatedConcentration / expectedConcentration);
result = result.ChangeUnits(SrmSettings.PeptideSettings.Quantification.Units);
}
return(result);
}
protected static CalibrationCurve LinearFit(IList <WeightedPoint> points)
{
CalibrationCurve calibrationCurve = new CalibrationCurve().ChangePointCount(points.Count);
try
{
double[] values = WeightedRegression.Weighted(points.Select(p => new Tuple <double[], double>(new[] { p.X }, p.Y)),
points.Select(p => p.Weight).ToArray(), true);
calibrationCurve = calibrationCurve.ChangeSlope(values[1]).ChangeIntercept(values[0]);
}
catch (Exception ex)
{
calibrationCurve = calibrationCurve.ChangeErrorMessage(ex.Message);
}
return(calibrationCurve);
}
public FiguresOfMerit GetFiguresOfMerit(CalibrationCurve calibrationCurve)
{
var figuresOfMerit = FiguresOfMerit.EMPTY;
if (calibrationCurve != null)
{
figuresOfMerit = figuresOfMerit.ChangeLimitOfDetection(
QuantificationSettings.LodCalculation.CalculateLod(calibrationCurve, this));
}
figuresOfMerit = figuresOfMerit.ChangeLimitOfQuantification(GetLimitOfQuantification(calibrationCurve));
if (!FiguresOfMerit.EMPTY.Equals(figuresOfMerit))
{
figuresOfMerit = figuresOfMerit.ChangeUnits(QuantificationSettings.Units);
}
return(figuresOfMerit);
}
public virtual CalibrationCurve Fit(IList <WeightedPoint> points)
{
try
{
CalibrationCurve curve = FitPoints(points);
if (curve != null)
{
curve = curve.ChangeRegressionFit(this);
curve = AddRSquared(curve, points);
}
return(curve);
}
catch (Exception e)
{
return(new CalibrationCurve(this).ChangeErrorMessage(e.Message));
}
}
public QuantificationResult GetPrecursorQuantificationResult(int replicateIndex, TransitionGroupDocNode transitionGroupDocNode)
{
QuantificationResult result = new QuantificationResult();
var calibrationPoint = new CalibrationPoint(replicateIndex, transitionGroupDocNode.LabelType);
CalibrationCurve calibrationCurve = GetCalibrationCurve();
result = result.ChangeNormalizedArea(GetNormalizedPeakArea(calibrationPoint));
if (HasExternalStandards() || HasInternalStandardConcentration())
{
double?calculatedConcentration = GetCalculatedConcentration(calibrationCurve, calibrationPoint);
result = result.ChangeCalculatedConcentration(calculatedConcentration);
double?expectedConcentration = transitionGroupDocNode.PrecursorConcentration;
result = result.ChangeAccuracy(calculatedConcentration / expectedConcentration);
result = result.ChangeUnits(SrmSettings.PeptideSettings.Quantification.Units);
}
return(result);
}
public QuantificationResult GetPeptideQuantificationResult(int replicateIndex)
{
CalibrationCurve calibrationCurve = GetCalibrationCurve();
QuantificationResult result = new QuantificationResult();
result = result.ChangeNormalizedArea(GetNormalizedPeakArea(new CalibrationPoint(replicateIndex, null)));
if (HasExternalStandards() || HasInternalStandardConcentration())
{
double?calculatedConcentration = GetCalculatedConcentration(calibrationCurve, new CalibrationPoint(replicateIndex, null));
result = result.ChangeCalculatedConcentration(calculatedConcentration);
double?expectedConcentration = GetPeptideConcentration(replicateIndex);
result = result.ChangeAccuracy(calculatedConcentration / expectedConcentration);
result = result.ChangeUnits(QuantificationSettings.Units);
}
return(result);
}
/// <summary>
/// Optimization function used when doing NelderMeadSimplex to find the best Limit of Detection.
/// </summary>
private static double LodObjectiveFunction(double lod, IList <WeightedPoint> weightedPoints)
{
CalibrationCurve calibrationCurve = GetCalibrationCurveWithLod(lod, weightedPoints);
if (calibrationCurve == null || !calibrationCurve.TurningPoint.HasValue)
{
return(double.MaxValue);
}
double totalDelta = 0;
double totalWeight = 0;
foreach (var pt in weightedPoints)
{
double delta = pt.Y - calibrationCurve.GetY(pt.X).Value;
totalWeight += pt.Weight;
totalDelta += pt.Weight * delta * delta;
}
return(totalDelta / totalWeight);
}
public override double?GetFittedX(CalibrationCurve calibrationCurve, double?y)
{
// Quadratic formula: x = (-b +/- sqrt(b^2-4ac))/2a
double?a = calibrationCurve.QuadraticCoefficient;
double?b = calibrationCurve.Slope;
double?c = calibrationCurve.Intercept - y;
double?discriminant = b * b - 4 * a * c;
if (!discriminant.HasValue)
{
return(null);
}
if (discriminant < 0)
{
return(double.NaN);
}
double sqrtDiscriminant = Math.Sqrt(discriminant.Value);
return((-b + sqrtDiscriminant) / 2 / a);
}
public static double?BlankPlusSdMultiple(CalibrationCurve calibrationCurve, CalibrationCurveFitter fitter, double sdMultiple)
{
List <double> blankPeakAreas = new List <double>();
var measuredResults = fitter.SrmSettings.MeasuredResults;
if (measuredResults == null)
{
return(null);
}
for (int iReplicate = 0; iReplicate < measuredResults.Chromatograms.Count; iReplicate++)
{
var chromatogramSet = measuredResults.Chromatograms[iReplicate];
if (!SampleType.BLANK.Equals(chromatogramSet.SampleType))
{
continue;
}
double?peakArea = fitter.GetNormalizedPeakArea(new CalibrationPoint(iReplicate, null));
if (!peakArea.HasValue)
{
continue;
}
blankPeakAreas.Add(peakArea.Value);
}
if (!blankPeakAreas.Any())
{
return(null);
}
double meanPlusSd = blankPeakAreas.Mean();
if (sdMultiple != 0)
{
meanPlusSd = blankPeakAreas.StandardDeviation() * sdMultiple;
}
if (double.IsNaN(meanPlusSd) || double.IsInfinity(meanPlusSd))
{
return(null);
}
return(calibrationCurve.GetFittedX(meanPlusSd));
}
public double?CalculateLod(CalibrationCurve calibrationCurve, CalibrationCurveFitter calibrationCurveFitter)
{
return(_calculateLodFunc(calibrationCurve, calibrationCurveFitter));
}
public override double?GetY(CalibrationCurve calibrationCurve, double?x)
{
return(x * x * calibrationCurve.QuadraticCoefficient + x * calibrationCurve.Slope + calibrationCurve.Intercept);
}
private LineItem CreateInterpolatedLine(CalibrationCurve calibrationCurve, double minX, double maxX, int pointCount, bool logPlot)
{
PointPairList pointPairList = new PointPairList();
for (int i = 0; i < pointCount; i++)
{
double x;
if (logPlot)
{
x = Math.Exp((Math.Log(minX)*(pointCount - 1 - i) + Math.Log(maxX)*i)/(pointCount - 1));
}
else
{
x = (minX*(pointCount - 1 - i) + maxX*i)/(pointCount - 1);
}
double? y = calibrationCurve.GetY(x);
if (y.HasValue)
{
pointPairList.Add(x, y.Value);
}
}
if (!pointPairList.Any())
{
return null;
}
return new LineItem(QuantificationStrings.Calibration_Curve, pointPairList, Color.Gray, SymbolType.None);
}
public static double?CalculateLodFromTurningPoint(CalibrationCurve calibrationCurve,
CalibrationCurveFitter fitter)
{
return(calibrationCurve.TurningPoint);
}
public double?GetCalculatedXValue(CalibrationCurve calibrationCurve, int replicateIndex)
{
return(calibrationCurve.GetX(GetYValue(replicateIndex)));
}
public double?GetCalculatedConcentration(CalibrationCurve calibrationCurve, int iReplicate)
{
return(GetCalculatedConcentration(calibrationCurve, new CalibrationPoint(iReplicate, null)));
}
public double? GetCalculatedXValue(CalibrationCurve calibrationCurve, int replicateIndex)
{
return calibrationCurve.GetX(GetYValue(replicateIndex));
}
public double?GetCalculatedXValue(CalibrationCurve calibrationCurve, CalibrationPoint calibrationPoint)
{
return(calibrationCurve.GetX(GetYValue(calibrationPoint)));
}
public virtual double?GetY(CalibrationCurve calibrationCurve, double?x)
{
return(x * calibrationCurve.Slope + calibrationCurve.Intercept.GetValueOrDefault());
}
public CalibrationCurve AddRSquared(CalibrationCurve curve, IList<WeightedPoint> points)
{
List<double> yValues = new List<double>();
List<double> residuals = new List<double>();
foreach (var point in points)
{
double? yFitted = curve.GetY(point.X);
if (!yFitted.HasValue)
{
continue;
}
yValues.Add(point.Y);
residuals.Add(point.Y - yFitted.Value);
}
if (!residuals.Any())
{
return curve;
}
double yMean = yValues.Average();
double totalSumOfSquares = yValues.Sum(y => (y - yMean)*(y - yMean));
double sumOfSquaresOfResiduals = residuals.Sum(r => r*r);
double rSquared = 1 - sumOfSquaresOfResiduals/totalSumOfSquares;
return curve.ChangeRSquared(rSquared);
}
public virtual double?GetX(CalibrationCurve calibrationCurve, double?y)
{
return(GetFittedX(calibrationCurve, y));
}
public virtual double?GetFittedX(CalibrationCurve calibrationCurve, double?y)
{
return((y - calibrationCurve.Intercept.GetValueOrDefault()) / calibrationCurve.Slope);
}
public override double?GetX(CalibrationCurve calibrationCurve, double?y)
{
return(GetFittedX(calibrationCurve, y));
}
public double? GetCalculatedConcentration(CalibrationCurve calibrationCurve, int replicateIndex)
{
if (!HasExternalStandards() && !HasInternalStandardConcentration())
{
return null;
}
double? xValue = GetCalculatedXValue(calibrationCurve, replicateIndex);
if (HasExternalStandards() && HasInternalStandardConcentration())
{
return xValue*PeptideQuantifier.PeptideDocNode.InternalStandardConcentration;
}
return xValue;
}
