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);
}
/// <summary>
/// Align retention times with a target.
/// For the MS2 Id's that are found in both the target and the timesToAlign, the MS2 id's
/// are plotted against each other, and a linear regression is performed.
/// In cases where there is more than one MS2 id in either file, only the earliest MS2 id from
/// each file is used.
/// </summary>
public static AlignedRetentionTimes AlignLibraryRetentionTimes(IDictionary <Target, double> target, IDictionary <Target, double> originalTimes, double refinementThreshhold, RegressionMethodRT regressionMethod,
Func <bool> isCanceled)
{
var calculator = new DictionaryRetentionScoreCalculator("alignment", originalTimes); // Not L10N
var targetTimesList = new List <MeasuredRetentionTime>();
foreach (var entry in calculator.RetentionTimes)
{
double targetTime;
if (!target.TryGetValue(entry.Key, out targetTime))
{
continue;
}
MeasuredRetentionTime measuredRetentionTime;
try
{
measuredRetentionTime = new MeasuredRetentionTime(entry.Key, targetTime);
}
catch
{
continue;
}
targetTimesList.Add(measuredRetentionTime);
}
RetentionTimeStatistics regressionStatistics;
var regression = RetentionTimeRegression.CalcRegression(XmlNamedElement.NAME_INTERNAL, new[] { calculator }, regressionMethod, targetTimesList, out regressionStatistics);
if (regression == null)
{
return(null);
}
RetentionTimeRegression regressionRefined;
RetentionTimeStatistics regressionRefinedStatistics = regressionStatistics;
HashSet <int> outIndexes = new HashSet <int>();
if (regressionStatistics.R >= refinementThreshhold)
{
regressionRefined = regression;
}
else
{
var cache = new RetentionTimeScoreCache(new[] { calculator }, new MeasuredRetentionTime[0], null);
regressionRefined = regression.FindThreshold(refinementThreshhold, null, 0,
targetTimesList.Count, new MeasuredRetentionTime[0], targetTimesList, null, regressionStatistics,
calculator, regressionMethod, cache, isCanceled, ref regressionRefinedStatistics,
ref outIndexes);
}
return(new AlignedRetentionTimes
{
TargetTimes = target,
OriginalTimes = originalTimes,
Regression = regression,
RegressionStatistics = regressionStatistics,
RegressionRefined = regressionRefined,
RegressionRefinedStatistics = regressionRefinedStatistics,
OutlierIndexes = outIndexes,
Calculator = calculator
});
}
private static FileRetentionTimeAlignments CalculateFileRetentionTimeAlignments(
string dataFileName, ResultNameMap <IDictionary <Target, double> > libraryRetentionTimes, IProgressMonitor progressMonitor)
{
var targetTimes = libraryRetentionTimes.Find(dataFileName);
if (targetTimes == null)
{
return(null);
}
var alignments = new List <RetentionTimeAlignment>();
foreach (var entry in libraryRetentionTimes)
{
if (dataFileName == entry.Key)
{
continue;
}
var alignedFile = AlignedRetentionTimes.AlignLibraryRetentionTimes(targetTimes, entry.Value, REFINEMENT_THRESHHOLD, RegressionMethodRT.linear, new CustomCancellationToken(CancellationToken.None, () => progressMonitor.IsCanceled));
if (alignedFile == null || alignedFile.RegressionRefinedStatistics == null ||
!RetentionTimeRegression.IsAboveThreshold(alignedFile.RegressionRefinedStatistics.R, REFINEMENT_THRESHHOLD))
{
continue;
}
var regressionLine = alignedFile.RegressionRefined.Conversion as RegressionLineElement;
if (regressionLine != null)
{
alignments.Add(new RetentionTimeAlignment(entry.Key, regressionLine));
}
}
return(new FileRetentionTimeAlignments(dataFileName, alignments));
}
private bool PointIsOverEx(RTLinearRegressionGraphPane graphPane, PointF point,
RetentionTimeRegression regression, double x, double y)
{
if (regression != null && regression.IsUsable)
{
y = GetResidual(regression, x, y);
}
return(graphPane.PointIsOver(point, x, y));
}
private double[] GetResiduals(RetentionTimeRegression regression, double[] scores, double[] times)
{
var residualsRefined = new double[times.Length];
for (int i = 0; i < residualsRefined.Length; i++)
{
residualsRefined[i] = GetResidual(regression, scores[i], times[i]);
}
return(residualsRefined);
}
private RetentionScoreCalculatorSpec RecalcRegression(IList <RetentionScoreCalculatorSpec> calculators, IList <MeasuredRetentionTime> peptidesTimes)
{
RetentionScoreCalculatorSpec calculatorSpec;
RetentionTimeStatistics statistics;
var regression = RetentionTimeRegression.CalcRegression("Recalc", // Not L10N
calculators,
RegressionMethodRT.linear,
peptidesTimes,
out statistics);
double r = 0;
if (regression == null)
{
if (calculators.Count() > 1)
{
textSlope.Text = string.Empty;
textIntercept.Text = string.Empty;
textTimeWindow.Text = string.Empty;
comboCalculator.SelectedIndex = -1;
return(null);
}
calculatorSpec = calculators.First();
}
else
{
var regressionLine = regression.Conversion as RegressionLineElement;
if (regressionLine != null)
{
textSlope.Text = string.Format("{0}", regressionLine.Slope); // Not L10N
textIntercept.Text = string.Format("{0}", regressionLine.Intercept); // Not L10N
}
textTimeWindow.Text = string.Format("{0:F01}", regression.TimeWindow); // Not L10N
// Select best calculator match.
calculatorSpec = regression.Calculator;
// Save statistics to show in RTDetails form.
_statistics = statistics;
r = statistics.R;
}
int minCount;
var pepCount = calculatorSpec.ChooseRegressionPeptides(peptidesTimes.Select(mrt => mrt.PeptideSequence), out minCount).Count();
labelRValue.Text = string.Format(Resources.EditRTDlg_RecalcRegression__0__peptides_R__1__, pepCount,
Math.Round(r, RetentionTimeRegression.ThresholdPrecision));
// Right align with the peptide grid.
labelRValue.Left = gridPeptides.Right - labelRValue.Width;
return(calculatorSpec);
}
public bool IsRefined()
{
// If refinement has been performed, or it doesn't need to be.
if (_regressionRefined != null)
{
return(true);
}
if (_statisticsAll == null)
{
return(false);
}
return(RetentionTimeRegression.IsAboveThreshold(_statisticsAll.R, _threshold));
}
private RetentionScoreCalculatorSpec RecalcRegression(IList <RetentionScoreCalculatorSpec> calculators, IList <MeasuredRetentionTime> peptidesTimes)
{
var summary = RetentionTimeRegression.CalcBestRegressionLongOperationRunner(XmlNamedElement.NAME_INTERNAL, calculators, peptidesTimes,
null, false, RegressionMethodRT.linear, CustomCancellationToken.NONE);
var regression = summary.Best.Regression;
var statistics = summary.Best.Statistics;
var calculatorSpec = summary.Best.Calculator;
double r = 0;
if (regression == null)
{
if (calculators.Count > 1)
{
textSlope.Text = string.Empty;
textIntercept.Text = string.Empty;
textTimeWindow.Text = string.Empty;
comboCalculator.SelectedIndex = -1;
return(null);
}
calculatorSpec = calculators.First();
}
else
{
var regressionLine = regression.Conversion as RegressionLineElement;
if (regressionLine != null)
{
textSlope.Text = string.Format(@"{0}", regressionLine.Slope);
textIntercept.Text = string.Format(@"{0}", regressionLine.Intercept);
}
textTimeWindow.Text = string.Format(@"{0:F01}", regression.TimeWindow);
// Select best calculator match.
calculatorSpec = regression.Calculator;
// Save statistics to show in RTDetails form.
_statistics = statistics;
r = statistics.R;
}
int minCount;
var pepCount = calculatorSpec.ChooseRegressionPeptides(peptidesTimes.Select(mrt => mrt.PeptideSequence), out minCount).Count();
labelRValue.Text = string.Format(Resources.EditRTDlg_RecalcRegression__0__peptides_R__1__, pepCount,
Math.Round(r, RetentionTimeRegression.ThresholdPrecision));
// Right align with the peptide grid.
labelRValue.Left = gridPeptides.Right - labelRValue.Width;
return(calculatorSpec);
}
public void CalcRetentionTime(RetentionTimeRegression rtRegression)
{
double?rt = null;
if (rtRegression != null)
{
double?score = rtRegression.Calculator.ScoreSequence(Sequence);
if (score.HasValue)
{
rt = rtRegression.Conversion.GetY(score.Value);
}
}
PredictedRetentionTime = rt;
}
public static SrmDocument AddRetentionTimePredictor(SrmDocument doc, LibrarySpec libSpec)
{
var calc = new RCalcIrt(
Helpers.GetUniqueName(libSpec.Name, Settings.Default.RTScoreCalculatorList.Select(lib => lib.Name).ToArray()),
libSpec.FilePath);
var predictor = new RetentionTimeRegression(
Helpers.GetUniqueName(libSpec.Name, Settings.Default.RetentionTimeList.Select(rt => rt.Name).ToArray()),
calc, null, null, DEFAULT_RT_WINDOW, new List <MeasuredRetentionTime>());
Settings.Default.RTScoreCalculatorList.Add(calc);
Settings.Default.RetentionTimeList.Add(predictor);
return(doc.ChangeSettings(
doc.Settings.ChangePeptideSettings(
doc.Settings.PeptideSettings.ChangePrediction(
doc.Settings.PeptideSettings.Prediction.ChangeRetentionTime(predictor)))));
}
private static float AddRegressionLabel(PaneBase graphPane, Graphics g, double score, double time,
RetentionTimeRegression regression, RetentionTimeStatistics statistics, Color color)
{
string label;
if (regression == null || regression.Conversion == null || statistics == null)
{
label = String.Format("{0} = ?, {1} = ?\n" + "{2} = ?\n" + "r = ?", // Not L10N
Resources.Regression_slope,
Resources.Regression_intercept,
Resources.GraphData_AddRegressionLabel_window);
}
else
{
label = String.Format("{0} = {1:F02}, {2} = {3:F02}\n" + "{4} = {5:F01}\n" + "r = {6}", // Not L10N
Resources.Regression_slope,
regression.Conversion.Slope,
Resources.Regression_intercept,
regression.Conversion.Intercept,
Resources.GraphData_AddRegressionLabel_window,
regression.TimeWindow,
Math.Round(statistics.R, RetentionTimeRegression.ThresholdPrecision));
}
TextObj text = new TextObj(label, score, time,
CoordType.AxisXYScale, AlignH.Left, AlignV.Top)
{
IsClippedToChartRect = true,
ZOrder = ZOrder.E_BehindCurves,
FontSpec = GraphSummary.CreateFontSpec(color),
};
graphPane.GraphObjList.Add(text);
// Measure the text just added, and return its height
SizeF sizeLabel = text.FontSpec.MeasureString(g, label, graphPane.CalcScaleFactor());
return(sizeLabel.Height + 3);
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
double window;
if (!helper.ValidateDecimalTextBox(txtWindow, out window))
{
return;
}
if (Settings.Default.RetentionTimeList.Any(regression => regression.Name == txtName.Text))
{
MessageDlg.Show(this, Resources.AddRetentionTimePredictorDlg_OkDialog_A_retention_time_predictor_with_that_name_already_exists__Please_choose_a_new_name_);
txtName.Focus();
return;
}
Regression = new RetentionTimeRegression(
txtName.Text, Calculator, null, null, window, new List <MeasuredRetentionTime>());
DialogResult = DialogResult.OK;
}
public void SettingsChangeNotDoc()
{
SrmDocument docFasta = CreateMixedDoc();
SrmSettings settings = docFasta.Settings;
// Change declustering potential, collision energy, and retention time
var regressions = new DeclusterPotentialList();
regressions.AddDefaults();
var dpRegress = regressions["SCIEX"];
var collisions = new CollisionEnergyList();
collisions.AddDefaults();
var ceRegress = collisions["SCIEX"];
var calc = Settings.Default.RTScoreCalculatorList.GetDefaults().First();
var rtRegress = new RetentionTimeRegression("Test", calc, 3.5, 10.4, 12.8,
new MeasuredRetentionTime[0]);
SrmSettings settings2 = settings.ChangePeptidePrediction(p => p.ChangeRetentionTime(rtRegress)).
ChangeTransitionPrediction(p => p.ChangeCollisionEnergy(ceRegress).ChangeDeclusteringPotential(dpRegress));
SrmDocument docFasta2 = docFasta.ChangeSettings(settings2);
AssertEx.IsDocumentState(docFasta2, docFasta.RevisionIndex + 1, 3, 111, 352);
Assert.AreSame(docFasta.Children, docFasta2.Children);
Assert.AreNotEqual(docFasta.Settings, docFasta2.Settings);
// Change auto-select toggles
SrmSettings settings3 = settings.ChangePeptideFilter(f => f.ChangeAutoSelect(false)).
ChangeTransitionFilter(f => f.ChangeAutoSelect(false));
SrmDocument docFasta3 = docFasta.ChangeSettings(settings3);
AssertEx.IsDocumentState(docFasta3, docFasta.RevisionIndex + 1, 3, 111, 352);
Assert.AreSame(docFasta.Children, docFasta3.Children);
Assert.AreNotEqual(docFasta.Settings, docFasta3.Settings);
}
private double GetResidual(RetentionTimeRegression regression, double score, double time)
{
return(time - regression.Conversion.GetY(score));
}
public PeptidePrediction(RetentionTimeRegression retentionTime, DriftTimePredictor driftTimePredictor, bool useMeasuredRTs, double? measuredRTWindow,
bool useLibraryDriftTimes, double? libraryDriftTimesResolvingPower)
{
RetentionTime = retentionTime;
DriftTimePredictor = driftTimePredictor;
UseMeasuredRTs = useMeasuredRTs;
MeasuredRTWindow = measuredRTWindow;
UseLibraryDriftTimes = useLibraryDriftTimes;
LibraryDriftTimesResolvingPower = libraryDriftTimesResolvingPower;
DoValidate();
}
public PeptidePrediction ChangeRetentionTime(RetentionTimeRegression prop)
{
return ChangeProp(ImClone(this), im => im.RetentionTime = prop);
}
private static RetentionTimeRegression AutoCalcRegressions(IDocumentContainer container,
RetentionTimeRegression rtRegression)
{
var document = container.Document;
var dictSeqToPeptide = new Dictionary<string, PeptideDocNode>();
foreach (var nodePep in document.Peptides)
{
if (nodePep.IsDecoy)
continue;
string seqMod = document.Settings.GetSourceTextId(nodePep);
if (!dictSeqToPeptide.ContainsKey(seqMod))
dictSeqToPeptide.Add(seqMod, nodePep);
}
int minCount = 0;
try
{
var regressionPeps = rtRegression.Calculator.ChooseRegressionPeptides(dictSeqToPeptide.Keys, out minCount);
var setRegression = new HashSet<string>(regressionPeps);
dictSeqToPeptide = dictSeqToPeptide.Where(p => setRegression.Contains(p.Key))
.ToDictionary(p => p.Key, p => p.Value);
}
catch (IncompleteStandardException)
{
// Without a full set of regression peptides, no auto-calculation is possible
dictSeqToPeptide.Clear();
}
var dictStandardPeptides = dictSeqToPeptide.ToDictionary(p => p.Value.Peptide.GlobalIndex, p => p.Value);
// Must have standard peptides, all with results
if (dictSeqToPeptide.Count == 0)
return rtRegression.ClearEquations();
else if (dictSeqToPeptide.Values.Any(nodePep => !nodePep.HasResults))
return rtRegression.ClearEquations(dictStandardPeptides);
var calculator = rtRegression.Calculator;
var dictSeqToScore = dictSeqToPeptide.ToDictionary(p => p.Key,
p => calculator.ScoreSequence(p.Key) ?? calculator.UnknownScore);
var dictFileIdToCorr = new Dictionary<int, IList<TimeScorePair>>();
var listPepCorr = new List<TimeScorePair>();
foreach (var seqToPeptide in dictSeqToPeptide)
{
var nodePep = seqToPeptide.Value;
double? time = nodePep.SchedulingTime;
if (!time.HasValue)
continue;
double score = dictSeqToScore[seqToPeptide.Key];
listPepCorr.Add(new TimeScorePair(time.Value, score));
foreach (var fileId in nodePep.Results.Where(r => r != null)
.SelectMany(r => r)
.Select(chromInfo => chromInfo.FileId))
{
IList<TimeScorePair> listTimeScores;
if (!dictFileIdToCorr.TryGetValue(fileId.GlobalIndex, out listTimeScores))
listTimeScores = dictFileIdToCorr[fileId.GlobalIndex] = new List<TimeScorePair>();
time = nodePep.GetSchedulingTime(fileId);
if (!time.HasValue)
continue;
listTimeScores.Add(new TimeScorePair(time.Value, score));
}
}
// If not all standard peptides have at least some retention time value, fail prediction
if (listPepCorr.Count != dictSeqToPeptide.Count)
return rtRegression.ClearEquations(dictStandardPeptides);
// Only calculate regressions for files with retention times for all of the standards
var fileIdToConversions = from p in dictFileIdToCorr
where p.Value.Count == dictSeqToPeptide.Count
select new KeyValuePair<int, RegressionLine>(p.Key, CalcConversion(p.Value, minCount));
return rtRegression.ChangeEquations(new RegressionLineElement(CalcConversion(listPepCorr, minCount)),
fileIdToConversions,
dictStandardPeptides);
}
private static float AddRegressionLabel(PaneBase graphPane, Graphics g, double score, double time,
RetentionTimeRegression regression, RetentionTimeStatistics statistics, Color color)
{
string label;
if (regression == null || regression.Conversion == null || statistics == null)
{
label = String.Format("{0} = ?, {1} = ?\n" + "{2} = ?\n" + "r = ?", // Not L10N
Resources.Regression_slope,
Resources.Regression_intercept,
Resources.GraphData_AddRegressionLabel_window);
}
else
{
label = String.Format("{0} = {1:F02}, {2} = {3:F02}\n" + "{4} = {5:F01}\n" + "r = {6}", // Not L10N
Resources.Regression_slope,
regression.Conversion.Slope,
Resources.Regression_intercept,
regression.Conversion.Intercept,
Resources.GraphData_AddRegressionLabel_window,
regression.TimeWindow,
Math.Round(statistics.R, RetentionTimeRegression.ThresholdPrecision));
}
TextObj text = new TextObj(label, score, time,
CoordType.AxisXYScale, AlignH.Left, AlignV.Top)
{
IsClippedToChartRect = true,
ZOrder = ZOrder.E_BehindCurves,
FontSpec = GraphSummary.CreateFontSpec(color),
};
graphPane.GraphObjList.Add(text);
// Measure the text just added, and return its height
SizeF sizeLabel = text.FontSpec.MeasureString(g, label, graphPane.CalcScaleFactor());
return sizeLabel.Height + 3;
}
public void CalcRetentionTime(RetentionTimeRegression rtRegression)
{
double? rt = null;
if (rtRegression != null)
{
double? score = rtRegression.Calculator.ScoreSequence(Sequence);
if (score.HasValue)
rt = rtRegression.Conversion.GetY(score.Value);
}
PredictedRetentionTime = rt;
}
public PeptidePrediction(RetentionTimeRegression retentionTime, DriftTimePredictor driftTimePredictor = null)
: this(retentionTime, driftTimePredictor, true, DEFAULT_MEASURED_RT_WINDOW, false, null)
{
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
double window;
if (!helper.ValidateDecimalTextBox(txtWindow, out window))
return;
if (Settings.Default.RetentionTimeList.Any(regression => regression.Name == txtName.Text))
{
MessageDlg.Show(this, Resources.AddRetentionTimePredictorDlg_OkDialog_A_retention_time_predictor_with_that_name_already_exists__Please_choose_a_new_name_);
txtName.Focus();
return;
}
Regression = new RetentionTimeRegression(
txtName.Text, Calculator, null, null, window, new List<MeasuredRetentionTime>());
DialogResult = DialogResult.OK;
}
protected void TestUsePredictedTime()
{
const double FILTER_LENGTH = 2.7;
RunUI(() => SkylineWindow.OpenFile(TestFilesDir.GetTestPath("RetentionTimeFilterTest.sky")));
WaitForDocumentLoaded();
RunUI(() => SkylineWindow.SaveDocument(TestFilesDir.GetTestPath("TestUsePredictedTime.sky")));
SetUiDocument(ChangeFullScanSettings(SkylineWindow.Document, SkylineWindow.Document.Settings.TransitionSettings.FullScan
.ChangeRetentionTimeFilter(RetentionTimeFilterType.scheduling_windows, FILTER_LENGTH)));
Assert.IsNull(SkylineWindow.Document.Settings.PeptideSettings.Prediction.RetentionTime);
Assert.IsFalse(SkylineWindow.Document.Settings.PeptideSettings.Prediction.UseMeasuredRTs);
// When we try to import a file, we should get an error about not having a peptide prediction algorithm
var messageDlg = ShowDialog<MessageDlg>(() => SkylineWindow.ImportResults());
RunUI(() =>
{
Assert.AreEqual(Resources.SkylineWindow_CheckRetentionTimeFilter_NoPredictionAlgorithm, messageDlg.Message);
messageDlg.Close();
});
var ssrCalcRegression = new RetentionTimeRegression("SSRCALC_FOR_RtFilterTest",
new RetentionScoreCalculator(RetentionTimeRegression.SSRCALC_100_A), .63,
5.8, 1.4, new MeasuredRetentionTime[0]);
// Now give the document a prediction algorithm
SetUiDocument(ChangePeptidePrediction(SkylineWindow.Document, SkylineWindow.Document.Settings.PeptideSettings.
Prediction.ChangeRetentionTime(ssrCalcRegression)));
// Now import two result files
{
var importResultsDlg = ShowDialog<ImportResultsDlg>(SkylineWindow.ImportResults);
var openDataSourceDialog = ShowDialog<OpenDataSourceDialog>(importResultsDlg.OkDialog);
RunUI(() =>
{
openDataSourceDialog.SelectFile("200fmol" + extension);
openDataSourceDialog.SelectFile("20fmol" + extension);
});
OkDialog(openDataSourceDialog, openDataSourceDialog.Open);
}
WaitForResultsImport();
{
var document = WaitForDocumentLoaded();
foreach (var chromatogramSet in document.Settings.MeasuredResults.Chromatograms)
{
foreach (var tuple in LoadAllChromatograms(document, chromatogramSet))
{
var peptide = tuple.Item1;
if (!peptide.IsProteomic)
continue;
var transitionGroup = tuple.Item2;
var predictedRetentionTime = ssrCalcRegression.GetRetentionTime(
document.Settings.GetModifiedSequence(peptide.Peptide.Sequence,
transitionGroup.TransitionGroup.LabelType, peptide.ExplicitMods)).Value;
AssertChromatogramWindow(document, chromatogramSet,
predictedRetentionTime - FILTER_LENGTH,
predictedRetentionTime + FILTER_LENGTH, tuple.Item3);
}
}
}
ChromatogramSet chromSetForScheduling = SkylineWindow.Document.Settings.MeasuredResults.Chromatograms[1];
// Create a SrmDocument with just the one ChromatogramSet that we are going to use for scheduling, so that
// we can assert later that the chromatogram windows are where this document says they should be.
SrmDocument documentForScheduling =
SkylineWindow.Document.ChangeMeasuredResults(
SkylineWindow.Document.Settings.MeasuredResults.ChangeChromatograms(new[] {chromSetForScheduling}));
SetUiDocument(ChangePeptidePrediction(SkylineWindow.Document, SkylineWindow.Document.Settings.PeptideSettings
.Prediction.ChangeUseMeasuredRTs(true).ChangeRetentionTime(null)));
{
var chooseSchedulingReplicatesDlg = ShowDialog<ChooseSchedulingReplicatesDlg>(SkylineWindow.ImportResults);
// Choose a scheduling replicate (the one saved above)
RunUI(() => Assert.IsTrue(chooseSchedulingReplicatesDlg.TrySetReplicateChecked(
chromSetForScheduling, true)));
var importResultsDlg = ShowDialog<ImportResultsDlg>(chooseSchedulingReplicatesDlg.OkDialog);
var openDataSourceDialog = ShowDialog<OpenDataSourceDialog>(importResultsDlg.OkDialog);
RunUI(()=>openDataSourceDialog.SelectFile("40fmol" + extension));
OkDialog(openDataSourceDialog, openDataSourceDialog.Open);
}
WaitForResultsImport();
{
var document = WaitForDocumentLoaded();
var chromatogramSet = document.Settings.MeasuredResults.Chromatograms.First(cs => cs.Name == "40fmol");
int countNull = 0;
foreach (var tuple in LoadAllChromatograms(document, chromatogramSet))
{
var prediction = new PeptidePrediction(null, null, true, 1, false, 0);
double windowRtIgnored;
var schedulingPeptide =
documentForScheduling.Molecules.First(pep => ReferenceEquals(pep.Peptide, tuple.Item1.Peptide));
var schedulingTransitionGroup = (TransitionGroupDocNode) schedulingPeptide.FindNode(tuple.Item2.TransitionGroup);
double? predictedRt = prediction.PredictRetentionTime(documentForScheduling,
schedulingPeptide,
schedulingTransitionGroup,
null, ExportSchedulingAlgorithm.Average, true, out windowRtIgnored);
if (!predictedRt.HasValue)
{
countNull++;
continue;
}
AssertChromatogramWindow(document, chromatogramSet, predictedRt.Value - FILTER_LENGTH, predictedRt.Value + FILTER_LENGTH, tuple.Item3);
}
Assert.AreEqual((TestSmallMolecules ? 1 : 0), countNull);
}
// Test using iRT with auto-calculated regression
{
const string calcName = "TestCalculator";
const string regressionName = "TestCalculatorAutoCalcRegression";
var peptideSettingsDlg = ShowDialog<PeptideSettingsUI>(SkylineWindow.ShowPeptideSettingsUI);
var editIrtDlg = ShowDialog<EditIrtCalcDlg>(peptideSettingsDlg.AddCalculator);
RunUI(() =>
{
editIrtDlg.OpenDatabase(TestFilesDir.GetTestPath("RetentionTimeFilterTest.irtdb"));
editIrtDlg.CalcName = calcName;
});
SkylineWindow.BeginInvoke(new Action(editIrtDlg.OkDialog));
var multiButtonMsgDlg = WaitForOpenForm<MultiButtonMsgDlg>();
OkDialog(multiButtonMsgDlg, ()=>multiButtonMsgDlg.DialogResult = DialogResult.Yes);
var editRtDlg = ShowDialog<EditRTDlg>(peptideSettingsDlg.AddRTRegression);
RunUI(() =>
{
editRtDlg.ChooseCalculator(calcName);
editRtDlg.SetAutoCalcRegression(true);
editRtDlg.SetRegressionName(regressionName);
editRtDlg.SetTimeWindow(1.0);
});
OkDialog(editRtDlg, editRtDlg.OkDialog);
RunUI(() =>
{
peptideSettingsDlg.ChooseRegression(regressionName);
peptideSettingsDlg.UseMeasuredRT(false);
});
OkDialog(peptideSettingsDlg, peptideSettingsDlg.OkDialog);
Assert.IsFalse(SkylineWindow.Document.Settings.PeptideSettings.Prediction.UseMeasuredRTs);
var importResultsDlg = ShowDialog<ImportResultsDlg>(SkylineWindow.ImportResults);
var openDataSourceDialog = ShowDialog<OpenDataSourceDialog>(importResultsDlg.OkDialog);
RunUI(() => openDataSourceDialog.SelectFile("8fmol" + extension));
OkDialog(openDataSourceDialog, openDataSourceDialog.Open);
WaitForResultsImport();
var document = WaitForDocumentLoaded();
var chromatogramSet = document.Settings.MeasuredResults.Chromatograms.First(cs => cs.Name == "8fmol");
var regressionLine =
document.Settings.PeptideSettings.Prediction.RetentionTime.GetConversion(
chromatogramSet.MSDataFileInfos.First().FileId);
var calculator = document.Settings.PeptideSettings.Prediction.RetentionTime.Calculator;
double fullGradientStartTime;
double fullGradientEndTime;
using (var msDataFile = new MsDataFileImpl(TestFilesDir.GetTestPath("8fmol" + extension)))
{
fullGradientStartTime = msDataFile.GetSpectrum(0).RetentionTime.Value;
fullGradientEndTime = msDataFile.GetSpectrum(msDataFile.SpectrumCount - 1).RetentionTime.Value;
}
foreach (var tuple in LoadAllChromatograms(document, chromatogramSet))
{
if (tuple.Item1.GlobalStandardType != PeptideDocNode.STANDARD_TYPE_IRT)
{
double? score =
calculator.ScoreSequence(document.Settings.GetModifiedSequence(tuple.Item1.Peptide.Sequence,
tuple.Item2.TransitionGroup.LabelType, tuple.Item1.ExplicitMods));
if (score.HasValue)
{
double? predictedRt = regressionLine.GetY(score.Value);
AssertChromatogramWindow(document, chromatogramSet, predictedRt.Value - FILTER_LENGTH,
predictedRt.Value + FILTER_LENGTH, tuple.Item3);
}
}
else
{
// IRT Standards get extracted for the full gradient
AssertChromatogramWindow(document, chromatogramSet, fullGradientStartTime, fullGradientEndTime, tuple.Item3);
}
}
}
}
private double[] GetResiduals(RetentionTimeRegression regression, double[] scores, double[] times)
{
var residualsRefined = new double[times.Length];
for (int i = 0; i < residualsRefined.Length; i++)
residualsRefined[i] = GetResidual(regression, scores[i], times[i]);
return residualsRefined;
}
public void OkDialog()
{
var helper = new MessageBoxHelper(this);
string name;
if (!helper.ValidateNameTextBox(textName, out name))
{
return;
}
if (_existing.Contains(r => !ReferenceEquals(_regression, r) && Equals(name, r.Name)))
{
helper.ShowTextBoxError(textName, Resources.EditRTDlg_OkDialog_The_retention_time_regression__0__already_exists, name);
return;
}
double?slope = null;
double?intercept = null;
if (!cbAutoCalc.Checked)
{
double slopeTmp;
if (!helper.ValidateDecimalTextBox(textSlope, out slopeTmp))
{
return;
}
slope = slopeTmp;
double interceptTmp;
if (!helper.ValidateDecimalTextBox(textIntercept, out interceptTmp))
{
return;
}
intercept = interceptTmp;
}
double window;
if (!helper.ValidateDecimalTextBox(textTimeWindow, out window))
{
return;
}
if (window <= 0)
{
helper.ShowTextBoxError(textTimeWindow, Resources.EditRTDlg_OkDialog__0__must_be_greater_than_0);
return;
}
if (comboCalculator.SelectedIndex == -1)
{
MessageBox.Show(this, Resources.EditRTDlg_OkDialog_Retention_time_prediction_requires_a_calculator_algorithm,
Program.Name);
comboCalculator.Focus();
return;
}
var calculator = _driverCalculators.SelectedItem;
RetentionTimeRegression regression =
new RetentionTimeRegression(name, calculator, slope, intercept, window, GetTablePeptides());
_regression = regression;
DialogResult = DialogResult.OK;
}
protected void TestUsePredictedTime()
{
const double FILTER_LENGTH = 2.7;
RunUI(() => SkylineWindow.OpenFile(TestFilesDir.GetTestPath("RetentionTimeFilterTest.sky")));
var docStart = WaitForDocumentLoaded();
RunUI(() => SkylineWindow.SaveDocument(TestFilesDir.GetTestPath("TestUsePredictedTime.sky")));
SetUiDocument(docStart.ChangeSettings(docStart.Settings.ChangeTransitionFullScan(f =>
f.ChangeRetentionTimeFilter(RetentionTimeFilterType.scheduling_windows, FILTER_LENGTH))));
Assert.IsNull(SkylineWindow.Document.Settings.PeptideSettings.Prediction.RetentionTime);
Assert.IsFalse(SkylineWindow.Document.Settings.PeptideSettings.Prediction.UseMeasuredRTs);
// When we try to import a file, we should get an error about not having a peptide prediction algorithm
var messageDlg = ShowDialog <MessageDlg>(() => SkylineWindow.ImportResults());
RunUI(() =>
{
Assert.AreEqual(Resources.SkylineWindow_CheckRetentionTimeFilter_NoPredictionAlgorithm, messageDlg.Message);
messageDlg.Close();
});
var ssrCalcRegression = new RetentionTimeRegression("SSRCALC_FOR_RtFilterTest",
new RetentionScoreCalculator(RetentionTimeRegression.SSRCALC_100_A), .63,
5.8, 1.4, new MeasuredRetentionTime[0]);
// Now give the document a prediction algorithm
var docBeforeImport = SkylineWindow.Document;
docBeforeImport = docBeforeImport.ChangeSettings(docBeforeImport.Settings.ChangePeptidePrediction(p =>
p.ChangeRetentionTime(ssrCalcRegression)));
SetUiDocument(docBeforeImport);
// Now import two result files
{
var importResultsDlg = ShowDialog <ImportResultsDlg>(SkylineWindow.ImportResults);
var openDataSourceDialog = ShowDialog <OpenDataSourceDialog>(importResultsDlg.OkDialog);
RunUI(() =>
{
openDataSourceDialog.SelectFile("200fmol" + extension);
openDataSourceDialog.SelectFile("20fmol" + extension);
});
OkDialog(openDataSourceDialog, openDataSourceDialog.Open);
}
{
var document = WaitForDocumentChangeLoaded(docBeforeImport);
foreach (var chromatogramSet in document.Settings.MeasuredResults.Chromatograms)
{
foreach (var tuple in LoadAllChromatograms(document, chromatogramSet))
{
var peptide = tuple.Item1;
if (!peptide.IsProteomic)
{
continue;
}
var transitionGroup = tuple.Item2;
var predictedRetentionTime = ssrCalcRegression.GetRetentionTime(
document.Settings.GetModifiedSequence(peptide.Peptide.Sequence,
transitionGroup.TransitionGroup.LabelType, peptide.ExplicitMods)).Value;
AssertChromatogramWindow(document, chromatogramSet,
predictedRetentionTime - FILTER_LENGTH,
predictedRetentionTime + FILTER_LENGTH, tuple.Item3);
}
}
}
ChromatogramSet chromSetForScheduling = SkylineWindow.Document.Settings.MeasuredResults.Chromatograms[1];
// Create a SrmDocument with just the one ChromatogramSet that we are going to use for scheduling, so that
// we can assert later that the chromatogram windows are where this document says they should be.
var docForScheduling = SkylineWindow.Document.ChangeMeasuredResults(
SkylineWindow.Document.Settings.MeasuredResults.ChangeChromatograms(new[] { chromSetForScheduling }));
docForScheduling = docForScheduling.ChangeSettings(docForScheduling.Settings.ChangePeptidePrediction(p =>
p.ChangeUseMeasuredRTs(true).ChangeRetentionTime(null)));
SetUiDocument(docForScheduling);
{
var chooseSchedulingReplicatesDlg = ShowDialog <ChooseSchedulingReplicatesDlg>(SkylineWindow.ImportResults);
// Choose a scheduling replicate (the one saved above)
RunUI(() => Assert.IsTrue(chooseSchedulingReplicatesDlg.TrySetReplicateChecked(
chromSetForScheduling, true)));
var importResultsDlg = ShowDialog <ImportResultsDlg>(chooseSchedulingReplicatesDlg.OkDialog);
var openDataSourceDialog = ShowDialog <OpenDataSourceDialog>(importResultsDlg.OkDialog);
RunUI(() => openDataSourceDialog.SelectFile("40fmol" + extension));
OkDialog(openDataSourceDialog, openDataSourceDialog.Open);
}
{
var document = WaitForDocumentChangeLoaded(docForScheduling);
var chromatogramSet = document.Settings.MeasuredResults.Chromatograms.First(cs => cs.Name == "40fmol");
int countNull = 0;
foreach (var tuple in LoadAllChromatograms(document, chromatogramSet))
{
var prediction = new PeptidePrediction(null, null, true, 1, false, 0);
double windowRtIgnored;
var schedulingPeptide =
docForScheduling.Molecules.First(pep => ReferenceEquals(pep.Peptide, tuple.Item1.Peptide));
var schedulingTransitionGroup = (TransitionGroupDocNode)schedulingPeptide.FindNode(tuple.Item2.TransitionGroup);
double?predictedRt = prediction.PredictRetentionTime(docForScheduling,
schedulingPeptide,
schedulingTransitionGroup,
null, ExportSchedulingAlgorithm.Average, true, out windowRtIgnored);
if (!predictedRt.HasValue)
{
countNull++;
continue;
}
AssertChromatogramWindow(document, chromatogramSet, predictedRt.Value - FILTER_LENGTH, predictedRt.Value + FILTER_LENGTH, tuple.Item3);
}
Assert.AreEqual((TestSmallMolecules ? 1 : 0), countNull);
}
// Test using iRT with auto-calculated regression
{
const string calcName = "TestCalculator";
const string regressionName = "TestCalculatorAutoCalcRegression";
var peptideSettingsDlg = ShowDialog <PeptideSettingsUI>(SkylineWindow.ShowPeptideSettingsUI);
var editIrtDlg = ShowDialog <EditIrtCalcDlg>(peptideSettingsDlg.AddCalculator);
RunUI(() =>
{
editIrtDlg.OpenDatabase(TestFilesDir.GetTestPath("RetentionTimeFilterTest.irtdb"));
editIrtDlg.CalcName = calcName;
});
SkylineWindow.BeginInvoke(new Action(editIrtDlg.OkDialog));
var multiButtonMsgDlg = WaitForOpenForm <MultiButtonMsgDlg>();
OkDialog(multiButtonMsgDlg, () => multiButtonMsgDlg.DialogResult = DialogResult.Yes);
var editRtDlg = ShowDialog <EditRTDlg>(peptideSettingsDlg.AddRTRegression);
RunUI(() =>
{
editRtDlg.ChooseCalculator(calcName);
editRtDlg.SetAutoCalcRegression(true);
editRtDlg.SetRegressionName(regressionName);
editRtDlg.SetTimeWindow(1.0);
});
OkDialog(editRtDlg, editRtDlg.OkDialog);
RunUI(() =>
{
peptideSettingsDlg.ChooseRegression(regressionName);
peptideSettingsDlg.UseMeasuredRT(false);
});
OkDialog(peptideSettingsDlg, peptideSettingsDlg.OkDialog);
Assert.IsFalse(SkylineWindow.Document.Settings.PeptideSettings.Prediction.UseMeasuredRTs);
docBeforeImport = SkylineWindow.Document;
var importResultsDlg = ShowDialog <ImportResultsDlg>(SkylineWindow.ImportResults);
var openDataSourceDialog = ShowDialog <OpenDataSourceDialog>(importResultsDlg.OkDialog);
RunUI(() => openDataSourceDialog.SelectFile("8fmol" + extension));
OkDialog(openDataSourceDialog, openDataSourceDialog.Open);
var document = WaitForDocumentChangeLoaded(docBeforeImport);
var chromatogramSet = document.Settings.MeasuredResults.Chromatograms.First(cs => cs.Name == "8fmol");
var regressionLine =
document.Settings.PeptideSettings.Prediction.RetentionTime.GetConversion(
chromatogramSet.MSDataFileInfos.First().FileId);
var calculator = document.Settings.PeptideSettings.Prediction.RetentionTime.Calculator;
double fullGradientStartTime;
double fullGradientEndTime;
using (var msDataFile = new MsDataFileImpl(TestFilesDir.GetTestPath("8fmol" + extension)))
{
fullGradientStartTime = msDataFile.GetSpectrum(0).RetentionTime.Value;
fullGradientEndTime = msDataFile.GetSpectrum(msDataFile.SpectrumCount - 1).RetentionTime.Value;
}
foreach (var tuple in LoadAllChromatograms(document, chromatogramSet))
{
if (tuple.Item1.GlobalStandardType != PeptideDocNode.STANDARD_TYPE_IRT)
{
double?score =
calculator.ScoreSequence(document.Settings.GetModifiedSequence(tuple.Item1.Peptide.Sequence,
tuple.Item2.TransitionGroup.LabelType, tuple.Item1.ExplicitMods));
if (score.HasValue)
{
double?predictedRt = regressionLine.GetY(score.Value);
AssertChromatogramWindow(document, chromatogramSet, predictedRt.Value - FILTER_LENGTH,
predictedRt.Value + FILTER_LENGTH, tuple.Item3);
}
}
else
{
// IRT Standards get extracted for the full gradient
AssertChromatogramWindow(document, chromatogramSet, fullGradientStartTime, fullGradientEndTime, tuple.Item3);
}
}
}
}
private bool PointIsOverEx(RTLinearRegressionGraphPane graphPane, PointF point,
RetentionTimeRegression regression, double x, double y)
{
if (regression != null && regression.IsUsable)
y = GetResidual(regression, x, y);
return graphPane.PointIsOver(point, x, y);
}
public void SettingsChangeNotDoc()
{
SrmDocument docFasta = CreateMixedDoc();
SrmSettings settings = docFasta.Settings;
// Change declustering potential, collision energy, and retention time
var regressions = new DeclusterPotentialList();
regressions.AddDefaults();
var dpRegress = regressions["ABI"];
var collisions = new CollisionEnergyList();
collisions.AddDefaults();
var ceRegress = collisions["ABI 4000 QTrap"];
var calc = Settings.Default.RTScoreCalculatorList.GetDefaults().First();
var rtRegress = new RetentionTimeRegression("Test", calc, 3.5, 10.4, 12.8,
new MeasuredRetentionTime[0]);
SrmSettings settings2 = settings.ChangePeptidePrediction(p => p.ChangeRetentionTime(rtRegress)).
ChangeTransitionPrediction(p => p.ChangeCollisionEnergy(ceRegress).ChangeDeclusteringPotential(dpRegress));
SrmDocument docFasta2 = docFasta.ChangeSettings(settings2);
AssertEx.IsDocumentState(docFasta2, docFasta.RevisionIndex + 1, 3, 111, 352);
Assert.AreSame(docFasta.Children, docFasta2.Children);
Assert.AreNotEqual(docFasta.Settings, docFasta2.Settings);
// Change auto-select toggles
SrmSettings settings3 = settings.ChangePeptideFilter(f => f.ChangeAutoSelect(false)).
ChangeTransitionFilter(f => f.ChangeAutoSelect(false));
SrmDocument docFasta3 = docFasta.ChangeSettings(settings3);
AssertEx.IsDocumentState(docFasta3, docFasta.RevisionIndex + 1, 3, 111, 352);
Assert.AreSame(docFasta.Children, docFasta3.Children);
Assert.AreNotEqual(docFasta.Settings, docFasta3.Settings);
}
public RegressionUnconversion(RetentionTimeRegression retentionTimeRegression)
{
_retentionTimeRegression = retentionTimeRegression;
}
public void OkDialog()
{
IrtType irtType = GetIrtType();
if (textCalculatorName.Text.Length == 0)
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_Calculator_name_cannot_be_empty);
return;
}
if (_existing.Select(spec => spec.Name).Contains(textCalculatorName.Text))
{
var replaceResult = MultiButtonMsgDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_A_calculator_with_that_name_already_exists___Do_you_want_to_replace_it_,
MultiButtonMsgDlg.BUTTON_YES,
MultiButtonMsgDlg.BUTTON_NO,
false);
if (replaceResult == DialogResult.No)
{
return;
}
}
if (irtType == IrtType.existing)
{
try
{
if (!File.Exists(textOpenDatabase.Text))
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_iRT_database_field_must_contain_a_path_to_a_valid_file_);
textOpenDatabase.Focus();
return;
}
var db = IrtDb.GetIrtDb(textOpenDatabase.Text, null);
if (db == null)
{
throw new DatabaseOpeningException(string.Format(Resources.CreateIrtCalculatorDlg_OkDialog_Cannot_read_the_database_file__0_, textOpenDatabase.Text));
}
}
catch (Exception x)
{
MessageDlg.ShowWithException(this, string.Format(Resources.CreateIrtCalculatorDlg_OkDialog_Failed_to_open_the_database_file___0_, x.Message), x);
return;
}
}
else if (irtType == IrtType.separate_list)
{
if (textNewDatabase.Text.Length == 0)
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_iRT_database_field_must_not_be_empty_);
textNewDatabase.Focus();
return;
}
if (!CreateIrtDatabase(textNewDatabase.Text))
{
return;
}
}
else
{
if (textNewDatabaseProteins.Text.Length == 0)
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_iRT_database_field_must_not_be_empty_);
textNewDatabaseProteins.Focus();
return;
}
if (comboBoxProteins.SelectedIndex == -1)
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_Please_select_a_protein_containing_the_list_of_standard_peptides_for_the_iRT_calculator_);
comboBoxProteins.Focus();
return;
}
if (!CreateIrtDatabase(textNewDatabaseProteins.Text))
{
return;
}
}
// Make a version of the document with the new calculator in it
var databaseFileName = irtType == IrtType.existing ? textOpenDatabase.Text :
irtType == IrtType.separate_list ? textNewDatabase.Text :
textNewDatabaseProteins.Text;
var calculator = new RCalcIrt(textCalculatorName.Text, databaseFileName);
// CONSIDER: Probably can't use just a static default like 10 below
var retentionTimeRegression = new RetentionTimeRegression(calculator.Name, calculator, null, null, RetentionTimeRegression.DEFAULT_WINDOW, new List <MeasuredRetentionTime>());
var docNew = Document.ChangeSettings(Document.Settings.ChangePeptidePrediction(prediction =>
prediction.ChangeRetentionTime(retentionTimeRegression)));
// Import transition list of standards, if applicable
if (irtType == IrtType.separate_list)
{
try
{
if (!File.Exists(textImportText.Text))
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_Transition_list_field_must_contain_a_path_to_a_valid_file_);
return;
}
IdentityPath selectPath;
List <MeasuredRetentionTime> irtPeptides;
List <TransitionImportErrorInfo> errorList;
var inputs = new MassListInputs(textImportText.Text);
docNew = docNew.ImportMassList(inputs, null, out selectPath, out irtPeptides, out _librarySpectra, out errorList);
if (errorList.Any())
{
throw new InvalidDataException(errorList[0].ErrorMessage);
}
_dbIrtPeptides = irtPeptides.Select(rt => new DbIrtPeptide(rt.PeptideSequence, rt.RetentionTime, true, TimeSource.scan)).ToList();
IrtFile = textImportText.Text;
}
catch (Exception x)
{
MessageDlg.ShowWithException(this, string.Format(Resources.CreateIrtCalculatorDlg_OkDialog_Error_reading_iRT_standards_transition_list___0_, x.Message), x);
return;
}
}
else if (irtType == IrtType.protein)
{
PeptideGroupDocNode selectedGroup = comboBoxProteins.SelectedItem as PeptideGroupDocNode;
// ReSharper disable PossibleNullReferenceException
_irtPeptideSequences = new HashSet <Target>(selectedGroup.Peptides.Select(pep => pep.ModifiedTarget));
// ReSharper restore PossibleNullReferenceException
}
Document = docNew;
DialogResult = DialogResult.OK;
}
public GraphData(SrmDocument document, GraphData dataPrevious,
int resultIndex, double threshold, int? thresholdPrecision, bool refine, bool bestResult)
{
_document = document;
_resultIndex = resultIndex;
_bestResult = bestResult;
_threshold = threshold;
_thresholdPrecision = thresholdPrecision;
_peptidesIndexes = new List<PeptideDocumentIndex>();
_peptidesTimes = new List<MeasuredRetentionTime>();
int index = -1;
// CONSIDER: Retention time prediction for small molecules?
foreach (var nodePeptide in document.Peptides)
{
index++;
float? rt = null;
if (!bestResult)
rt = nodePeptide.GetSchedulingTime(resultIndex);
else
{
int iBest = nodePeptide.BestResult;
if (iBest != -1)
rt = nodePeptide.GetSchedulingTime(iBest);
}
if (!rt.HasValue)
rt = 0;
_peptidesIndexes.Add(new PeptideDocumentIndex(nodePeptide, index));
string modSeq = _document.Settings.GetSourceTextId(nodePeptide);
_peptidesTimes.Add(new MeasuredRetentionTime(modSeq, rt.Value));
}
_calculatorName = Settings.Default.RTCalculatorName;
RetentionScoreCalculatorSpec calc = !string.IsNullOrEmpty(_calculatorName)
? Settings.Default.GetCalculatorByName(Settings.Default.RTCalculatorName)
: null;
if (calc == null)
{
// Initialize all calculators
Settings.Default.RTScoreCalculatorList.Initialize(null);
//This call will pick the best calculator, disqualifying any iRT Calcs that do not have
//connected databases
_regressionAll = RetentionTimeRegression.CalcRegression(XmlNamedElement.NAME_INTERNAL,
Settings.Default.RTScoreCalculatorList,
_peptidesTimes,
_scoreCache,
true,
out _statisticsAll,
out _calculator);
}
else
{
// Initialize the one calculator
calc = Settings.Default.RTScoreCalculatorList.Initialize(null, calc);
_regressionAll = RetentionTimeRegression.CalcRegression(XmlNamedElement.NAME_INTERNAL,
new[] {calc},
_peptidesTimes,
_scoreCache,
true,
out _statisticsAll,
out _calculator);
//If _regressionAll is null, it is safe to assume that the calculator is an iRT Calc with
//its database disconnected.
if(_regressionAll == null)
{
var tryIrtCalc = calc as RCalcIrt;
//Only show an error message if the user specifically chooses this calculator.
if (dataPrevious != null && !ReferenceEquals(calc, dataPrevious.Calculator) && tryIrtCalc != null)
{
throw new DatabaseNotConnectedException(tryIrtCalc);
}
}
}
if (_regressionAll != null)
{
_scoreCache = new RetentionTimeScoreCache(new[] { _calculator }, _peptidesTimes,
dataPrevious != null ? dataPrevious._scoreCache : null);
if (dataPrevious != null && !ReferenceEquals(_calculator, dataPrevious._calculator))
_scoreCache.RecalculateCalcCache(_calculator);
_scoresRefined = _statisticsAll.ListHydroScores.ToArray();
_timesRefined = _statisticsAll.ListRetentionTimes.ToArray();
}
_regressionPredict = document.Settings.PeptideSettings.Prediction.RetentionTime;
if (_regressionPredict != null)
{
if (!Equals(_calculator, _regressionPredict.Calculator))
_regressionPredict = null;
else
{
IDictionary<string, double> scoreCache = null;
if (_regressionAll != null && ReferenceEquals(_regressionAll.Calculator, _regressionPredict.Calculator))
scoreCache = _statisticsAll.ScoreCache;
_statisticsPredict = _regressionPredict.CalcStatistics(_peptidesTimes, scoreCache);
}
}
// Only refine, if not already exceeding the threshold
_refine = refine && !IsRefined();
}
private static RetentionTimeRegression AutoCalcRegressions(IDocumentContainer container,
RetentionTimeRegression rtRegression)
{
var document = container.Document;
var dictSeqToPeptide = new Dictionary <string, PeptideDocNode>();
foreach (var nodePep in document.Peptides)
{
if (nodePep.IsDecoy)
{
continue;
}
string seqMod = document.Settings.GetSourceTextId(nodePep);
if (!dictSeqToPeptide.ContainsKey(seqMod))
{
dictSeqToPeptide.Add(seqMod, nodePep);
}
}
int minCount = 0;
try
{
var regressionPeps = rtRegression.Calculator.ChooseRegressionPeptides(dictSeqToPeptide.Keys, out minCount);
var setRegression = new HashSet <string>(regressionPeps);
dictSeqToPeptide = dictSeqToPeptide.Where(p => setRegression.Contains(p.Key))
.ToDictionary(p => p.Key, p => p.Value);
}
catch (IncompleteStandardException)
{
// Without a full set of regression peptides, no auto-calculation is possible
dictSeqToPeptide.Clear();
}
var dictStandardPeptides = dictSeqToPeptide.ToDictionary(p => p.Value.Peptide.GlobalIndex, p => p.Value);
// Must have standard peptides, all with results
if (dictSeqToPeptide.Count == 0)
{
return(rtRegression.ClearEquations());
}
else if (dictSeqToPeptide.Values.Any(nodePep => !nodePep.HasResults))
{
return(rtRegression.ClearEquations(dictStandardPeptides));
}
var calculator = rtRegression.Calculator;
var dictSeqToScore = dictSeqToPeptide.ToDictionary(p => p.Key,
p => calculator.ScoreSequence(p.Key) ?? calculator.UnknownScore);
var dictFileIdToCorr = new Dictionary <int, IList <TimeScorePair> >();
var listPepCorr = new List <TimeScorePair>();
foreach (var seqToPeptide in dictSeqToPeptide)
{
var nodePep = seqToPeptide.Value;
double?time = nodePep.SchedulingTime;
if (!time.HasValue)
{
continue;
}
double score = dictSeqToScore[seqToPeptide.Key];
listPepCorr.Add(new TimeScorePair(time.Value, score));
foreach (var fileId in nodePep.Results.Where(r => r != null)
.SelectMany(r => r)
.Select(chromInfo => chromInfo.FileId))
{
IList <TimeScorePair> listTimeScores;
if (!dictFileIdToCorr.TryGetValue(fileId.GlobalIndex, out listTimeScores))
{
listTimeScores = dictFileIdToCorr[fileId.GlobalIndex] = new List <TimeScorePair>();
}
time = nodePep.GetSchedulingTime(fileId);
if (!time.HasValue)
{
continue;
}
listTimeScores.Add(new TimeScorePair(time.Value, score));
}
}
// If not all standard peptides have at least some retention time value, fail prediction
if (listPepCorr.Count != dictSeqToPeptide.Count)
{
return(rtRegression.ClearEquations(dictStandardPeptides));
}
// Only calculate regressions for files with retention times for all of the standards
var fileIdToConversions = from p in dictFileIdToCorr
where p.Value.Count == dictSeqToPeptide.Count
select new KeyValuePair <int, RegressionLine>(p.Key, CalcConversion(p.Value, minCount));
var line = CalcConversion(listPepCorr, minCount);
return(line != null
? rtRegression.ChangeEquations(new RegressionLineElement(line), fileIdToConversions, dictStandardPeptides)
: rtRegression.ChangeEquations(null, fileIdToConversions, dictStandardPeptides).ChangeInsufficientCorrelation(true));
}
private double GetResidual(RetentionTimeRegression regression, double score, double time)
{
return time - regression.Conversion.GetY(score);
}
public bool BuildLibrary(IProgressMonitor progress)
{
RetentionTimeRegression regr = null;
var standardSpectra = new List <SpectrumMzInfo>();
if (IrtStandard != null && !ReferenceEquals(IrtStandard, IrtStandard.EMPTY))
{
// Align Prosit iRTs with iRT standard
var standardPeptidesToAdd = SkylineWindow.ReadStandardPeptides(IrtStandard);
if (standardPeptidesToAdd != null && standardPeptidesToAdd.Count > 0)
{
// Get iRTs
var standardIRTMap = _rtModel.Predict(_prositClient, _document.Settings,
standardPeptidesToAdd.Select(p => (PrositRetentionTimeModel.PeptideDocNodeWrapper)p.NodePep).ToArray(),
CancellationToken.None);
var original = standardIRTMap.ToDictionary(p => p.Key.ModifiedTarget, p => p.Value);
var target = IrtStandard.Peptides.ToDictionary(p => p.ModifiedTarget, p => p.Irt);
var aligned = AlignedRetentionTimes.AlignLibraryRetentionTimes(target, original, 0.0, RegressionMethodRT.linear,
CancellationToken.None);
regr = aligned.Regression;
// Get spectra
var standardMS = _intensityModel.PredictBatches(_prositClient, progress, _document.Settings,
standardPeptidesToAdd.Select(p => p.WithNCE(_nce)).ToArray(),
CancellationToken.None);
// Merge iRT and MS2 into SpecMzInfos
standardSpectra = standardMS.Spectra.Select(m => m.SpecMzInfo).ToList();
for (var i = 0; i < standardSpectra.Count; ++i)
{
if (standardIRTMap.TryGetValue(standardMS.Spectra[i].PeptidePrecursorNCE.NodePep, out var iRT))
{
standardSpectra[i].RetentionTime = iRT;
}
}
}
}
// Predict fragment intensities
PrositMS2Spectra ms = _intensityModel.PredictBatches(_prositClient, progress, _document.Settings,
_peptides.Zip(_precursors,
(pep, prec) =>
new PrositIntensityModel.PeptidePrecursorNCE(pep, prec, _nce)).ToArray(),
CancellationToken.None);
var specMzInfo = ms.Spectra.Select(m => m.SpecMzInfo).ToList();
// Predict iRTs for peptides
var distinctPeps = _peptides.Select(p => (PrositRetentionTimeModel.PeptideDocNodeWrapper)p).Distinct(
new SystemLinqExtensionMethods.FuncEqualityComparer <PrositRetentionTimeModel.PeptideDocNodeWrapper>(
(p1, p2) => p1.Node.ModifiedSequence == p2.Node.ModifiedSequence)).ToArray();
var iRTMap = _rtModel.PredictBatches(_prositClient, progress, _document.Settings,
distinctPeps, CancellationToken.None);
for (var i = 0; i < specMzInfo.Count; ++i)
{
if (iRTMap.TryGetValue(ms.Spectra[i].PeptidePrecursorNCE.NodePep, out var iRT))
{
specMzInfo[i].RetentionTime = regr?.Conversion?.GetY(iRT) ?? iRT;
}
}
// Build library
var librarySpectra = SpectrumMzInfo.RemoveDuplicateSpectra(standardSpectra.Concat(specMzInfo).ToList());
// Delete if already exists, no merging with Prosit
var libraryExists = File.Exists(LibrarySpec.FilePath);
if (libraryExists)
{
var replace = _replaceLibrary();
if (!replace)
{
return(false);
}
FileEx.SafeDelete(LibrarySpec.FilePath);
}
if (!librarySpectra.Any())
{
return(true);
}
// Build the library
using (var blibDb = BlibDb.CreateBlibDb(LibrarySpec.FilePath))
{
var docLibrarySpec = new BiblioSpecLiteSpec(LibrarySpec.Name, LibrarySpec.FilePath);
BiblioSpecLiteLibrary docLibraryNew = null;
var docLibrarySpec2 = docLibrarySpec;
docLibraryNew =
blibDb.CreateLibraryFromSpectra(docLibrarySpec2, librarySpectra, LibrarySpec.Name, progress);
if (docLibraryNew == null)
{
return(false);
}
}
return(true);
}
private GraphData RefineCloned(double threshold, int?precision, Func <bool> isCanceled)
{
// Create list of deltas between predicted and measured times
_outlierIndexes = new HashSet <int>();
// Start with anything assigned a zero retention time as outliers
for (int i = 0; i < _peptidesTimes.Count; i++)
{
if (_peptidesTimes[i].RetentionTime == 0)
{
_outlierIndexes.Add(i);
}
}
// Now that we have added iRT calculators, RecalcRegression
// cannot go and mark as outliers peptides at will anymore. It must know which peptides, if any,
// are required by the calculator for a regression. With iRT calcs, the standard is required.
if (!_calculator.IsUsable)
{
return(null);
}
HashSet <string> standardNames;
try
{
var names = _calculator.GetStandardPeptides(_peptidesTimes.Select(pep => pep.PeptideSequence));
standardNames = new HashSet <string>(names);
}
catch (CalculatorException)
{
standardNames = new HashSet <string>();
}
var standardPeptides = _peptidesTimes.Where(pep => standardNames.Contains(pep.PeptideSequence)).ToArray();
var variablePeptides = _peptidesTimes.Where(pep => !standardNames.Contains(pep.PeptideSequence)).ToArray();
//Throws DatabaseNotConnectedException
_regressionRefined = (_regressionAll == null
? null
: _regressionAll.FindThreshold(threshold,
precision,
0,
variablePeptides.Length,
standardPeptides,
variablePeptides,
_statisticsAll,
_calculator,
_scoreCache,
isCanceled,
ref _statisticsRefined,
ref _outlierIndexes));
if (ReferenceEquals(_regressionRefined, _regressionAll))
{
return(null);
}
// Separate lists into acceptable and outliers
var listScoresRefined = new List <double>();
var listTimesRefined = new List <double>();
var listScoresOutliers = new List <double>();
var listTimesOutliers = new List <double>();
for (int i = 0; i < _scoresRefined.Length; i++)
{
if (_outlierIndexes.Contains(i))
{
listScoresOutliers.Add(_scoresRefined[i]);
listTimesOutliers.Add(_timesRefined[i]);
}
else
{
listScoresRefined.Add(_scoresRefined[i]);
listTimesRefined.Add(_timesRefined[i]);
}
}
_scoresRefined = listScoresRefined.ToArray();
_timesRefined = listTimesRefined.ToArray();
_scoresOutliers = listScoresOutliers.ToArray();
_timesOutliers = listTimesOutliers.ToArray();
return(this);
}
public void OkDialog()
{
IrtType irtType = GetIrtType();
if (textCalculatorName.Text.Length == 0)
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_Calculator_name_cannot_be_empty);
return;
}
if (_existing.Select(spec => spec.Name).Contains(textCalculatorName.Text))
{
var replaceResult = MultiButtonMsgDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_A_calculator_with_that_name_already_exists___Do_you_want_to_replace_it_,
MultiButtonMsgDlg.BUTTON_YES,
MultiButtonMsgDlg.BUTTON_NO,
false);
if (replaceResult == DialogResult.No)
return;
}
if (irtType == IrtType.existing)
{
try
{
if (!File.Exists(textOpenDatabase.Text))
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_iRT_database_field_must_contain_a_path_to_a_valid_file_);
textOpenDatabase.Focus();
return;
}
var db = IrtDb.GetIrtDb(textOpenDatabase.Text, null);
if (db == null)
{
throw new DatabaseOpeningException(string.Format(Resources.CreateIrtCalculatorDlg_OkDialog_Cannot_read_the_database_file__0_, textOpenDatabase.Text));
}
}
catch (Exception x)
{
MessageDlg.ShowWithException(this, string.Format(Resources.CreateIrtCalculatorDlg_OkDialog_Failed_to_open_the_database_file___0_, x.Message), x);
return;
}
}
else if (irtType == IrtType.separate_list)
{
if (textNewDatabase.Text.Length == 0)
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_iRT_database_field_must_not_be_empty_);
textNewDatabase.Focus();
return;
}
if (!CreateIrtDatabase(textNewDatabase.Text))
return;
}
else
{
if (textNewDatabaseProteins.Text.Length == 0)
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_iRT_database_field_must_not_be_empty_);
textNewDatabaseProteins.Focus();
return;
}
if (comboBoxProteins.SelectedIndex == -1)
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_Please_select_a_protein_containing_the_list_of_standard_peptides_for_the_iRT_calculator_);
comboBoxProteins.Focus();
return;
}
if (!CreateIrtDatabase(textNewDatabaseProteins.Text))
return;
}
// Make a version of the document with the new calculator in it
var databaseFileName = irtType == IrtType.existing ? textOpenDatabase.Text :
irtType == IrtType.separate_list ? textNewDatabase.Text :
textNewDatabaseProteins.Text;
var calculator = new RCalcIrt(textCalculatorName.Text, databaseFileName);
// CONSIDER: Probably can't use just a static default like 10 below
var retentionTimeRegression = new RetentionTimeRegression(calculator.Name, calculator, null, null, 10, new List<MeasuredRetentionTime>());
var docNew = Document.ChangeSettings(Document.Settings.ChangePeptidePrediction(prediction =>
prediction.ChangeRetentionTime(retentionTimeRegression)));
// Import transition list of standards, if applicable
if (irtType == IrtType.separate_list)
{
try
{
if (!File.Exists(textImportText.Text))
{
MessageDlg.Show(this, Resources.CreateIrtCalculatorDlg_OkDialog_Transition_list_field_must_contain_a_path_to_a_valid_file_);
return;
}
IdentityPath selectPath;
List<MeasuredRetentionTime> irtPeptides;
List<TransitionImportErrorInfo> errorList;
var inputs = new MassListInputs(textImportText.Text);
docNew = docNew.ImportMassList(inputs, null, out selectPath, out irtPeptides, out _librarySpectra, out errorList);
if (errorList.Any())
{
throw new InvalidDataException(errorList[0].ErrorMessage);
}
_dbIrtPeptides = irtPeptides.Select(rt => new DbIrtPeptide(rt.PeptideSequence, rt.RetentionTime, true, TimeSource.scan)).ToList();
IrtFile = textImportText.Text;
}
catch (Exception x)
{
MessageDlg.ShowWithException(this, string.Format(Resources.CreateIrtCalculatorDlg_OkDialog_Error_reading_iRT_standards_transition_list___0_, x.Message), x);
return;
}
}
else if (irtType == IrtType.protein)
{
PeptideGroupDocNode selectedGroup = comboBoxProteins.SelectedItem as PeptideGroupDocNode;
// ReSharper disable PossibleNullReferenceException
_irtPeptideSequences = new HashSet<string>(selectedGroup.Peptides.Select(pep => pep.ModifiedSequence));
// ReSharper restore PossibleNullReferenceException
}
Document = docNew;
DialogResult = DialogResult.OK;
}
private GraphData RefineCloned(double threshold, int? precision, Func<bool> isCanceled)
{
// Create list of deltas between predicted and measured times
_outlierIndexes = new HashSet<int>();
// Start with anything assigned a zero retention time as outliers
for (int i = 0; i < _peptidesTimes.Count; i++)
{
if (_peptidesTimes[i].RetentionTime == 0)
_outlierIndexes.Add(i);
}
// Now that we have added iRT calculators, RecalcRegression
// cannot go and mark as outliers peptides at will anymore. It must know which peptides, if any,
// are required by the calculator for a regression. With iRT calcs, the standard is required.
if(!_calculator.IsUsable)
return null;
HashSet<string> standardNames;
try
{
var names = _calculator.GetStandardPeptides(_peptidesTimes.Select(pep => pep.PeptideSequence));
standardNames = new HashSet<string>(names);
}
catch (CalculatorException)
{
standardNames = new HashSet<string>();
}
var standardPeptides = _peptidesTimes.Where(pep => standardNames.Contains(pep.PeptideSequence)).ToArray();
var variablePeptides = _peptidesTimes.Where(pep => !standardNames.Contains(pep.PeptideSequence)).ToArray();
//Throws DatabaseNotConnectedException
_regressionRefined = (_regressionAll == null
? null
: _regressionAll.FindThreshold(threshold,
precision,
0,
variablePeptides.Length,
standardPeptides,
variablePeptides,
_statisticsAll,
_calculator,
_scoreCache,
isCanceled,
ref _statisticsRefined,
ref _outlierIndexes));
if (ReferenceEquals(_regressionRefined, _regressionAll))
return null;
// Separate lists into acceptable and outliers
var listScoresRefined = new List<double>();
var listTimesRefined = new List<double>();
var listScoresOutliers = new List<double>();
var listTimesOutliers = new List<double>();
for (int i = 0; i < _scoresRefined.Length; i++)
{
if (_outlierIndexes.Contains(i))
{
listScoresOutliers.Add(_scoresRefined[i]);
listTimesOutliers.Add(_timesRefined[i]);
}
else
{
listScoresRefined.Add(_scoresRefined[i]);
listTimesRefined.Add(_timesRefined[i]);
}
}
_scoresRefined = listScoresRefined.ToArray();
_timesRefined = listTimesRefined.ToArray();
_scoresOutliers = listScoresOutliers.ToArray();
_timesOutliers = listTimesOutliers.ToArray();
return this;
}
private bool ImportTransitionList(CommandArgs commandArgs)
{
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Importing_transiton_list__0____, Path.GetFileName(commandArgs.TransitionListPath));
IdentityPath selectPath;
List<MeasuredRetentionTime> irtPeptides;
List<SpectrumMzInfo> librarySpectra;
List<TransitionImportErrorInfo> errorList;
List<PeptideGroupDocNode> peptideGroups;
var retentionTimeRegression = _doc.Settings.PeptideSettings.Prediction.RetentionTime;
RCalcIrt calcIrt = retentionTimeRegression != null ? (retentionTimeRegression.Calculator as RCalcIrt) : null;
var progressMonitor = new CommandProgressMonitor(_out, new ProgressStatus(string.Empty));
var inputs = new MassListInputs(commandArgs.TransitionListPath);
var docNew = _doc.ImportMassList(inputs, progressMonitor, null,
out selectPath, out irtPeptides, out librarySpectra, out errorList, out peptideGroups);
// If nothing was imported (e.g. operation was canceled or zero error-free transitions) and also no errors, just return
if (ReferenceEquals(docNew, _doc) && !errorList.Any())
return true;
// Show the errors or as warnings, if error transitions are ignore
if (errorList.Any())
{
string messageFormat = !commandArgs.IsIgnoreTransitionErrors
? Resources.CommandLine_ImportTransitionList_Error___line__0___column__1____2_
: Resources.CommandLine_ImportTransitionList_Warning___line__0___column__1____2_;
foreach (var errorMessage in errorList)
{
_out.WriteLine(messageFormat, errorMessage.Row, errorMessage.Column, errorMessage.ErrorMessage);
}
if (!commandArgs.IsIgnoreTransitionErrors)
return false;
}
if (!commandArgs.IsTransitionListAssayLibrary)
{
_doc = docNew;
return true;
}
if (irtPeptides.Count == 0 || librarySpectra.Count == 0)
{
if (irtPeptides.Any())
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Error__Imported_assay_library__0__lacks_ion_abundance_values_);
else if (librarySpectra.Any())
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Error__Imported_assay_library__0__lacks_iRT_values_);
else
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Error__Imported_assay_library__0__lacks_iRT_and_ion_abundance_values_);
return false;
}
string destinationPath = commandArgs.SaveFile ?? commandArgs.SkylineFile;
string documentLibrary = BiblioSpecLiteSpec.GetLibraryFileName(destinationPath);
// ReSharper disable once AssignNullToNotNullAttribute
string outputLibraryPath = Path.Combine(Path.GetDirectoryName(documentLibrary),
Path.GetFileNameWithoutExtension(documentLibrary) + BiblioSpecLiteSpec.ASSAY_NAME +
BiblioSpecLiteSpec.EXT);
bool libraryExists = File.Exists(outputLibraryPath);
string libraryName = Path.GetFileNameWithoutExtension(destinationPath) + BiblioSpecLiteSpec.ASSAY_NAME;
int indexOldLibrary = docNew.Settings.PeptideSettings.Libraries.LibrarySpecs.IndexOf(
spec => spec != null && spec.FilePath == outputLibraryPath);
bool libraryLinkedToDoc = indexOldLibrary != -1;
if (libraryExists && !libraryLinkedToDoc)
{
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Error__There_is_an_existing_library_with_the_same_name__0__as_the_document_library_to_be_created_,
libraryName);
return false;
}
var dbIrtPeptides = irtPeptides.Select(rt => new DbIrtPeptide(rt.PeptideSequence, rt.RetentionTime, false, TimeSource.scan)).ToList();
var dbIrtPeptidesFilter = ImportAssayLibraryHelper.GetUnscoredIrtPeptides(dbIrtPeptides, calcIrt);
// If there are no iRT peptides with different values than the database, don't import any iRT's
bool checkPeptides = false;
if (dbIrtPeptidesFilter.Any())
{
if (calcIrt == null)
{
string irtDatabasePath = commandArgs.IrtDatabasePath;
if (string.IsNullOrEmpty(irtDatabasePath))
irtDatabasePath = Path.ChangeExtension(destinationPath, IrtDb.EXT);
if (!string.IsNullOrEmpty(commandArgs.IrtStandardsPath))
{
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Importing_iRT_transition_list__0_, commandArgs.IrtStandardsPath);
var irtInputs = new MassListInputs(commandArgs.IrtStandardsPath);
try
{
List<SpectrumMzInfo> irtLibrarySpectra;
docNew = docNew.ImportMassList(irtInputs, null, out selectPath, out irtPeptides, out irtLibrarySpectra, out errorList);
if (errorList.Any())
{
throw new InvalidDataException(errorList[0].ErrorMessage);
}
librarySpectra.AddRange(irtLibrarySpectra);
dbIrtPeptidesFilter.AddRange(irtPeptides.Select(rt => new DbIrtPeptide(rt.PeptideSequence, rt.RetentionTime, true, TimeSource.scan)));
}
catch (Exception x)
{
_out.WriteLine(Resources.CommandLine_Run_Error__Failed_importing_the_file__0____1_, commandArgs.IrtStandardsPath, x.Message);
return false;
}
if (!CreateIrtDatabase(irtDatabasePath, commandArgs))
return false;
}
else if (!string.IsNullOrEmpty(commandArgs.IrtGroupName))
{
var nodeGroupIrt = docNew.PeptideGroups.FirstOrDefault(nodeGroup => nodeGroup.Name == commandArgs.IrtGroupName);
if (nodeGroupIrt == null)
{
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Error__The_name__0__specified_with__1__was_not_found_in_the_imported_assay_library_,
commandArgs.IrtGroupName, CommandArgs.ArgText(CommandArgs.ARG_IRT_STANDARDS_GROUP_NAME));
return false;
}
var irtPeptideSequences = new HashSet<string>(nodeGroupIrt.Peptides.Select(pep => pep.ModifiedSequence));
dbIrtPeptidesFilter.ForEach(pep => pep.Standard = irtPeptideSequences.Contains(pep.PeptideModSeq));
if (!CreateIrtDatabase(irtDatabasePath, commandArgs))
return false;
}
else if (!File.Exists(irtDatabasePath))
{
_out.Write(Resources.CommandLine_ImportTransitionList_Error__To_create_the_iRT_database___0___for_this_assay_library__you_must_specify_the_iRT_standards_using_either_of_the_arguments__1__or__2_,
irtDatabasePath, CommandArgs.ArgText(CommandArgs.ARG_IRT_STANDARDS_GROUP_NAME), CommandArgs.ArgText(CommandArgs.ARG_IRT_STANDARDS_FILE));
return false;
}
else
{
checkPeptides = true;
}
string irtCalcName = commandArgs.IrtCalcName ?? Path.GetFileNameWithoutExtension(destinationPath);
calcIrt = new RCalcIrt(irtCalcName, irtDatabasePath);
retentionTimeRegression = new RetentionTimeRegression(calcIrt.Name, calcIrt, null, null, 10, new List<MeasuredRetentionTime>());
docNew = docNew.ChangeSettings(docNew.Settings.ChangePeptidePrediction(prediction =>
prediction.ChangeRetentionTime(retentionTimeRegression)));
}
string dbPath = calcIrt.DatabasePath;
IrtDb db = IrtDb.GetIrtDb(dbPath, null);
if (checkPeptides)
{
var standards = docNew.Molecules.Where(m => db.IsStandard(m.RawTextId)).ToArray();
if (standards.Length != db.StandardPeptideCount)
{
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Warning__The_document_is_missing_iRT_standards);
foreach (var rawTextId in db.StandardPeptides.Where(s => !standards.Contains(nodePep => s == nodePep.RawTextId)))
{
_out.WriteLine(" " + rawTextId); // Not L10N
}
}
}
var oldPeptides = db.GetPeptides().ToList();
IList<DbIrtPeptide.Conflict> conflicts;
dbIrtPeptidesFilter = DbIrtPeptide.MakeUnique(dbIrtPeptidesFilter);
DbIrtPeptide.FindNonConflicts(oldPeptides, dbIrtPeptidesFilter, null, out conflicts);
// Warn about peptides that are present in the import and already in the database
foreach (var conflict in conflicts)
{
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Warning__The_iRT_calculator_already_contains__0__with_the_value__1___Ignoring__2_,
conflict.ExistingPeptide.PeptideModSeq, conflict.ExistingPeptide.Irt, conflict.NewPeptide.Irt);
}
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Importing__0__iRT_values_into_the_iRT_calculator__1_, dbIrtPeptidesFilter.Count, calcIrt.Name);
docNew = docNew.AddIrtPeptides(dbIrtPeptidesFilter, false, progressMonitor);
if (docNew == null)
return false;
}
librarySpectra = SpectrumMzInfo.RemoveDuplicateSpectra(librarySpectra);
if (libraryLinkedToDoc)
{
string oldName = docNew.Settings.PeptideSettings.Libraries.LibrarySpecs[indexOldLibrary].Name;
var libraryOld = docNew.Settings.PeptideSettings.Libraries.GetLibrary(oldName);
var additionalSpectra = SpectrumMzInfo.GetInfoFromLibrary(libraryOld);
additionalSpectra = SpectrumMzInfo.RemoveDuplicateSpectra(additionalSpectra);
librarySpectra = SpectrumMzInfo.MergeWithOverwrite(librarySpectra, additionalSpectra);
foreach (var stream in libraryOld.ReadStreams)
stream.CloseStream();
}
if (librarySpectra.Any())
{
// Delete the existing library; either it's not tied to the document or we've already extracted the spectra
_out.WriteLine(Resources.CommandLine_ImportTransitionList_Adding__0__spectra_to_the_library__1_, librarySpectra.Count, libraryName);
if (libraryExists)
{
FileEx.SafeDelete(outputLibraryPath);
FileEx.SafeDelete(Path.ChangeExtension(outputLibraryPath, BiblioSpecLiteSpec.EXT_REDUNDANT));
}
using (var blibDb = BlibDb.CreateBlibDb(outputLibraryPath))
{
var docLibrarySpec = new BiblioSpecLiteSpec(libraryName, outputLibraryPath);
var docLibrary = blibDb.CreateLibraryFromSpectra(docLibrarySpec, librarySpectra, libraryName,
progressMonitor);
if (docLibrary == null)
return false;
var newSettings = docNew.Settings.ChangePeptideLibraries(
libs => libs.ChangeLibrary(docLibrary, docLibrarySpec, indexOldLibrary));
docNew = docNew.ChangeSettings(newSettings, new SrmSettingsChangeMonitor(progressMonitor,
Resources.SkylineWindow_ImportMassList_Finishing_up_import));
}
}
_doc = docNew;
return true;
}
public GraphData(SrmDocument document, GraphData dataPrevious,
int resultIndex, double threshold, int?thresholdPrecision, bool refine, bool bestResult, PointsTypeRT pointsType)
{
_document = document;
_resultIndex = resultIndex;
_bestResult = bestResult;
_threshold = threshold;
_thresholdPrecision = thresholdPrecision;
_pointsType = pointsType;
_peptidesIndexes = new List <PeptideDocumentIndex>();
_peptidesTimes = new List <MeasuredRetentionTime>();
int index = -1;
var standards = new HashSet <string>();
if (RTGraphController.PointsType == PointsTypeRT.standards)
{
standards = document.GetRetentionTimeStandards();
}
// CONSIDER: Retention time prediction for small molecules?
foreach (var nodePeptide in document.Peptides)
{
index++;
switch (RTGraphController.PointsType)
{
default:
if (nodePeptide.IsDecoy)
{
continue;
}
break;
case PointsTypeRT.standards:
if (!standards.Contains(document.Settings.GetModifiedSequence(nodePeptide)))
{
continue;
}
break;
case PointsTypeRT.decoys:
if (!nodePeptide.IsDecoy)
{
continue;
}
break;
}
float?rt = null;
if (!bestResult)
{
rt = nodePeptide.GetSchedulingTime(resultIndex);
}
else
{
int iBest = nodePeptide.BestResult;
if (iBest != -1)
{
rt = nodePeptide.GetSchedulingTime(iBest);
}
}
if (!rt.HasValue)
{
rt = 0;
}
_peptidesIndexes.Add(new PeptideDocumentIndex(nodePeptide, index));
string modSeq = _document.Settings.GetSourceTextId(nodePeptide);
_peptidesTimes.Add(new MeasuredRetentionTime(modSeq, rt.Value));
}
_calculatorName = Settings.Default.RTCalculatorName;
RetentionScoreCalculatorSpec calc = !string.IsNullOrEmpty(_calculatorName)
? Settings.Default.GetCalculatorByName(Settings.Default.RTCalculatorName)
: null;
if (calc == null)
{
// Initialize all calculators
Settings.Default.RTScoreCalculatorList.Initialize(null);
//This call will pick the best calculator, disqualifying any iRT Calcs that do not have
//connected databases
_regressionAll = RetentionTimeRegression.CalcRegression(XmlNamedElement.NAME_INTERNAL,
Settings.Default.RTScoreCalculatorList,
_peptidesTimes,
_scoreCache,
true,
out _statisticsAll,
out _calculator);
}
else
{
// Initialize the one calculator
calc = Settings.Default.RTScoreCalculatorList.Initialize(null, calc);
_regressionAll = RetentionTimeRegression.CalcRegression(XmlNamedElement.NAME_INTERNAL,
new[] { calc },
_peptidesTimes,
_scoreCache,
true,
out _statisticsAll,
out _calculator);
//If _regressionAll is null, it is safe to assume that the calculator is an iRT Calc with
//its database disconnected.
if (_regressionAll == null)
{
var tryIrtCalc = calc as RCalcIrt;
//Only show an error message if the user specifically chooses this calculator.
if (dataPrevious != null && !ReferenceEquals(calc, dataPrevious.Calculator) && tryIrtCalc != null)
{
throw new DatabaseNotConnectedException(tryIrtCalc);
}
}
}
if (_regressionAll != null)
{
_scoreCache = new RetentionTimeScoreCache(new[] { _calculator }, _peptidesTimes,
dataPrevious != null ? dataPrevious._scoreCache : null);
if (dataPrevious != null && !ReferenceEquals(_calculator, dataPrevious._calculator))
{
_scoreCache.RecalculateCalcCache(_calculator);
}
_scoresRefined = _statisticsAll.ListHydroScores.ToArray();
_timesRefined = _statisticsAll.ListRetentionTimes.ToArray();
}
_regressionPredict = document.Settings.PeptideSettings.Prediction.RetentionTime;
if (_regressionPredict != null)
{
if (!Equals(_calculator, _regressionPredict.Calculator))
{
_regressionPredict = null;
}
else
{
IDictionary <string, double> scoreCache = null;
if (_regressionAll != null && ReferenceEquals(_regressionAll.Calculator, _regressionPredict.Calculator))
{
scoreCache = _statisticsAll.ScoreCache;
}
_statisticsPredict = _regressionPredict.CalcStatistics(_peptidesTimes, scoreCache);
}
}
// Only refine, if not already exceeding the threshold
_refine = refine && !IsRefined();
}
