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; }