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 static double?CalculateLodFromTurningPoint(CalibrationCurve calibrationCurve,
CalibrationCurveFitter fitter)
{
return(calibrationCurve.TurningPoint);
}
public double?CalculateLod(CalibrationCurve calibrationCurve, CalibrationCurveFitter calibrationCurveFitter)
{
return(_calculateLodFunc(calibrationCurve, calibrationCurveFitter));
}
public void TestSinglePointExternalCalibrationWithoutNormalization()
{
var srmDocument = LoadTestDocument();
srmDocument = ChangeStandardConcentrationCount(srmDocument, 1);
srmDocument = ChangeQuantificationSettings(srmDocument, QuantificationSettings.DEFAULT
.ChangeRegressionFit(RegressionFit.LINEAR_THROUGH_ZERO)
.ChangeNormalizationMethod(NormalizationMethod.NONE));
PeptideGroupDocNode protein = srmDocument.MoleculeGroups.First();
PeptideDocNode peptide = protein.Peptides.First();
peptide = peptide.ChangeInternalStandardConcentration(null);
PeptideQuantifier peptideQuantifier = PeptideQuantifier.GetPeptideQuantifier(srmDocument.Settings, protein, peptide);
CalibrationCurveFitter curveFitter = new CalibrationCurveFitter(peptideQuantifier, srmDocument.Settings);
Assert.AreEqual(QuantificationStrings.Analyte_Concentration, curveFitter.GetXAxisTitle());
Assert.AreEqual(QuantificationStrings.CalibrationCurveFitter_GetYAxisTitle_Peak_Area, curveFitter.GetYAxisTitle());
var chromatograms = srmDocument.Settings.MeasuredResults.Chromatograms;
var lightPrecursor = peptide.TransitionGroups
.First(tg => IsotopeLabelType.light.Equals(tg.TransitionGroup.LabelType));
for (int iReplicate = 0; iReplicate < chromatograms.Count; iReplicate++)
{
string msg = string.Format("Replicate {0}", iReplicate);
var expectedY = lightPrecursor.Results[iReplicate].First().Area.Value;
double? actualY = curveFitter.GetYValue(iReplicate).Value;
Assert.IsNotNull(actualY);
Assert.AreEqual(expectedY, actualY.Value, .01, msg);
var calibrationCurve = curveFitter.GetCalibrationCurve();
Assert.AreEqual(1, calibrationCurve.PointCount);
var expectedConcentration = expectedY / calibrationCurve.Slope.Value;
Assert.AreEqual(expectedConcentration,
curveFitter.GetCalculatedXValue(calibrationCurve, iReplicate).GetValueOrDefault(double.NaN), epsilon, msg);
Assert.AreEqual(expectedConcentration,
curveFitter.GetCalculatedConcentration(calibrationCurve, iReplicate).GetValueOrDefault(double.NaN), epsilon, msg);
var chromatogramSet = chromatograms[iReplicate];
if (Equals(chromatogramSet.SampleType, SampleType.STANDARD) && chromatogramSet.AnalyteConcentration.HasValue)
{
// Since there was only one standard, the regression line goes exactly through this sample.
Assert.AreEqual(expectedConcentration, chromatogramSet.AnalyteConcentration.Value * peptide.ConcentrationMultiplier.GetValueOrDefault(1.0), epsilon);
}
}
}
private void DisplayCalibrationCurve()
{
CalibrationCurveOptions options = Settings.Default.CalibrationCurveOptions;
zedGraphControl.GraphPane.YAxis.Type = zedGraphControl.GraphPane.XAxis.Type
= options.LogPlot ? AxisType.Log : AxisType.Linear;
zedGraphControl.GraphPane.Legend.IsVisible = options.ShowLegend;
_scatterPlots = null;
CalibrationCurve = null;
SrmDocument document = DocumentUiContainer.DocumentUI;
if (!document.Settings.HasResults)
{
zedGraphControl.GraphPane.Title.Text =
QuantificationStrings.CalibrationForm_DisplayCalibrationCurve_No_results_available;
return;
}
PeptideDocNode peptide = null;
PeptideGroupDocNode peptideGroup = null;
SequenceTree sequenceTree = _skylineWindow.SequenceTree;
if (null != sequenceTree)
{
PeptideTreeNode peptideTreeNode = sequenceTree.GetNodeOfType<PeptideTreeNode>();
if (null != peptideTreeNode)
{
peptide = peptideTreeNode.DocNode;
}
PeptideGroupTreeNode peptideGroupTreeNode = sequenceTree.GetNodeOfType<PeptideGroupTreeNode>();
if (null != peptideGroupTreeNode)
{
peptideGroup = peptideGroupTreeNode.DocNode;
}
}
if (null == peptide)
{
zedGraphControl.GraphPane.Title.Text =
QuantificationStrings
.CalibrationForm_DisplayCalibrationCurve_Select_a_peptide_to_see_its_calibration_curve;
return;
}
PeptideQuantifier peptideQuantifier = PeptideQuantifier.GetPeptideQuantifier(document.Settings, peptideGroup,
peptide);
CalibrationCurveFitter curveFitter = new CalibrationCurveFitter(peptideQuantifier, document.Settings);
if (peptideQuantifier.QuantificationSettings.RegressionFit == RegressionFit.NONE)
{
if (string.IsNullOrEmpty(
peptideQuantifier.QuantificationSettings.NormalizationMethod.IsotopeLabelTypeName))
{
zedGraphControl.GraphPane.Title.Text =
QuantificationStrings.CalibrationForm_DisplayCalibrationCurve_Use_the_Quantification_tab_on_the_Peptide_Settings_dialog_to_control_the_conversion_of_peak_areas_to_concentrations_;
}
else
{
if (!peptide.InternalStandardConcentration.HasValue)
{
zedGraphControl.GraphPane.Title.Text =
string.Format(QuantificationStrings.CalibrationForm_DisplayCalibrationCurve_To_convert_peak_area_ratios_to_concentrations__specify_the_internal_standard_concentration_for__0__, peptide);
}
else
{
zedGraphControl.GraphPane.Title.Text = null;
}
}
}
else
{
if (curveFitter.GetStandardConcentrations().Any())
{
zedGraphControl.GraphPane.Title.Text = null;
}
else
{
zedGraphControl.GraphPane.Title.Text = QuantificationStrings.CalibrationForm_DisplayCalibrationCurve_To_fit_a_calibration_curve__set_the_Sample_Type_of_some_replicates_to_Standard__and_specify_their_concentration_;
}
}
zedGraphControl.GraphPane.XAxis.Title.Text = curveFitter.GetXAxisTitle();
zedGraphControl.GraphPane.YAxis.Title.Text = curveFitter.GetYAxisTitle();
CalibrationCurve = curveFitter.GetCalibrationCurve();
double minX = double.MaxValue, maxX = double.MinValue;
_scatterPlots = new CurveList();
foreach (var sampleType in SampleType.ListSampleTypes())
{
if (!Options.DisplaySampleType(sampleType))
{
continue;
}
PointPairList pointPairList = new PointPairList();
for (int iReplicate = 0;
iReplicate < document.Settings.MeasuredResults.Chromatograms.Count;
iReplicate++)
{
ChromatogramSet chromatogramSet = document.Settings.MeasuredResults.Chromatograms[iReplicate];
if (!Equals(sampleType, chromatogramSet.SampleType))
{
continue;
}
double? y = curveFitter.GetYValue(iReplicate);
double? x = curveFitter.GetSpecifiedXValue(iReplicate)
?? curveFitter.GetCalculatedXValue(CalibrationCurve, iReplicate);
if (y.HasValue && x.HasValue)
{
PointPair point = new PointPair(x.Value, y.Value) {Tag = iReplicate};
pointPairList.Add(point);
if (!Options.LogPlot || x.Value > 0)
{
minX = Math.Min(minX, x.Value);
}
maxX = Math.Max(maxX, x.Value);
}
}
if (pointPairList.Any())
{
var lineItem = zedGraphControl.GraphPane.AddCurve(sampleType.ToString(), pointPairList,
sampleType.Color, sampleType.SymbolType);
lineItem.Line.IsVisible = false;
lineItem.Symbol.Fill = new Fill(sampleType.Color);
_scatterPlots.Add(lineItem);
}
}
List<string> labelLines = new List<String>();
RegressionFit regressionFit = document.Settings.PeptideSettings.Quantification.RegressionFit;
if (regressionFit != RegressionFit.NONE)
{
if (minX <= maxX)
{
int interpolatedLinePointCount = 100;
if (!options.LogPlot)
{
if (regressionFit == RegressionFit.LINEAR_THROUGH_ZERO)
{
minX = Math.Min(0, minX);
}
if (regressionFit != RegressionFit.QUADRATIC)
{
interpolatedLinePointCount = 2;
}
}
LineItem interpolatedLine = CreateInterpolatedLine(CalibrationCurve, minX, maxX,
interpolatedLinePointCount, Options.LogPlot);
if (null != interpolatedLine)
{
zedGraphControl.GraphPane.CurveList.Add(interpolatedLine);
}
}
labelLines.Add(CalibrationCurve.ToString());
if (CalibrationCurve.RSquared.HasValue)
{
labelLines.Add(QuantificationStrings.CalibrationForm_DisplayCalibrationCurve_ +
CalibrationCurve.RSquared.Value.ToString("0.####")); // Not L10N
}
if (!Equals(curveFitter.QuantificationSettings.RegressionWeighting, RegressionWeighting.NONE))
{
labelLines.Add(string.Format("{0}: {1}", // Not L10N
QuantificationStrings.Weighting, curveFitter.QuantificationSettings.RegressionWeighting));
}
}
if (options.ShowSelection)
{
double? ySelected = curveFitter.GetYValue(_skylineWindow.SelectedResultsIndex);
double? xSelected = curveFitter.GetCalculatedXValue(CalibrationCurve, _skylineWindow.SelectedResultsIndex);
if (xSelected.HasValue && ySelected.HasValue)
{
ArrowObj arrow = new ArrowObj(xSelected.Value, ySelected.Value, xSelected.Value,
ySelected.Value) {Line = {Color = GraphSummary.ColorSelected}};
zedGraphControl.GraphPane.GraphObjList.Insert(0, arrow);
}
var quantificationResult = curveFitter.GetQuantificationResult(_skylineWindow.SelectedResultsIndex);
if (quantificationResult.CalculatedConcentration.HasValue)
{
labelLines.Add(string.Format("{0} = {1}", // Not L10N
QuantificationStrings.Calculated_Concentration, quantificationResult));
}
else if (!quantificationResult.NormalizedArea.HasValue)
{
labelLines.Add(QuantificationStrings.CalibrationForm_DisplayCalibrationCurve_The_selected_replicate_has_missing_or_truncated_transitions);
}
}
if (labelLines.Any())
{
TextObj text = new TextObj(TextUtil.LineSeparate(labelLines), .01, 0,
CoordType.ChartFraction, AlignH.Left, AlignV.Top)
{
IsClippedToChartRect = true,
ZOrder = ZOrder.E_BehindCurves,
FontSpec = GraphSummary.CreateFontSpec(Color.Black),
};
zedGraphControl.GraphPane.GraphObjList.Add(text);
}
}
public QuantificationResult GetQuantification()
{
var quantifier = PeptideQuantifier.GetPeptideQuantifier(SrmDocument.Settings, Peptide.Protein.DocNode, Peptide.DocNode);
CalibrationCurveFitter curveFitter = new CalibrationCurveFitter(quantifier, SrmDocument.Settings);
return curveFitter.GetQuantificationResult(ResultFile.Replicate.ReplicateIndex);
}
