Beispiel #1
0
            public static IEnumerable <RegressionOption> All(SrmDocument document)
            {
                yield return(new RegressionOption(Resources.RegressionOption_All_Fixed_points));

                var docPeptides = new Dictionary <Target, PeptideDocNode>();

                foreach (var nodePep in document.Peptides.Where(nodePep => nodePep.PercentileMeasuredRetentionTime.HasValue && !nodePep.IsDecoy))
                {
                    if (!docPeptides.ContainsKey(nodePep.ModifiedTarget))
                    {
                        docPeptides[nodePep.ModifiedTarget] = nodePep;
                    }
                }

                foreach (var standard in Settings.Default.IrtStandardList.Where(standard => !ReferenceEquals(standard, IrtStandard.EMPTY)))
                {
                    var pepMatches = new List <Tuple <DbIrtPeptide, PeptideDocNode> >();
                    foreach (var pep in standard.Peptides)
                    {
                        if (docPeptides.TryGetValue(pep.GetNormalizedModifiedSequence(), out var nodePep))
                        {
                            pepMatches.Add(Tuple.Create(pep, nodePep));
                        }
                    }
                    if (RCalcIrt.TryGetRegressionLine(
                            pepMatches.Select(pep => (double)pep.Item2.PercentileMeasuredRetentionTime.Value).ToList(),
                            pepMatches.Select(pep => pep.Item1.Irt).ToList(),
                            RCalcIrt.MinStandardCount(standard.Peptides.Count), out var regressionLine))
                    {
                        yield return(new RegressionOption(standard.Name, regressionLine, pepMatches, null, false, false));
                    }
                }
            }
Beispiel #2
0
        private static RegressionLine GetRegression(TargetMap <double> knownIrts, DbIrtPeptide[] matchingPeptides, int?minPoints, out RegressionGraphData graphData)
        {
            graphData = null;

            var matchingPeptideIrts = new TargetMap <List <double> >(matchingPeptides.Select(pep =>
                                                                                             new KeyValuePair <Target, List <double> >(pep.ModifiedTarget, new List <double>())));

            foreach (var pep in matchingPeptides)
            {
                var list = matchingPeptideIrts[pep.ModifiedTarget];
                list.Add(pep.Irt);
            }
            var listX   = new List <double>();
            var listY   = new List <double>();
            var targets = new Dictionary <int, Target>();

            foreach (var(i, kvp) in matchingPeptideIrts.Where(kvp => kvp.Value.Count > 0).Select((kvp, i) => Tuple.Create(i, kvp)))
            {
                targets[i] = kvp.Key;
                listX.Add(new Statistics(kvp.Value).Median());
                listY.Add(knownIrts[kvp.Key]);
            }

            var regressionMinPoints = minPoints ?? RCalcIrt.MinStandardCount(knownIrts.Count);
            var removed             = new List <Tuple <double, double> >();

            if (!IrtRegression.TryGet <RegressionLine>(listX, listY, regressionMinPoints, out var regression, removed))
            {
                return(null);
            }

            var outliers = new HashSet <int>();

            for (var i = 0; i < listX.Count; i++)
            {
                if (removed.Contains(Tuple.Create(listX[i], listY[i])))
                {
                    outliers.Add(i);
                }
            }

            graphData = new RegressionGraphData
            {
                Title          = Resources.ChooseIrtStandardPeptidesDlg_OkDialog_Linear_regression,
                LabelX         = Resources.ChooseIrtStandardPeptidesDlg_OkDialog_Library_iRTs,
                LabelY         = Resources.ChooseIrtStandardPeptidesDlg_OkDialog_Known_iRTs,
                XValues        = listX.ToArray(),
                YValues        = listY.ToArray(),
                Tooltips       = targets.ToDictionary(target => target.Key, target => target.Value.ToString()),
                OutlierIndices = outliers,
                RegressionLine = regression,
                MinCorrelation = RCalcIrt.MIN_IRT_TO_TIME_CORRELATION,
                MinPoints      = regressionMinPoints,
            };
            return(regression as RegressionLine);
        }
Beispiel #3
0
        private static void removePeptidesAndImport(IrtStandard standard, int numPeptides)
        {
            Target[]      standardPeptides = null;
            List <Target> removedPeptides  = null;

            RunUI(() =>
            {
                standardPeptides = standard.Peptides.Select(pep => pep.Target).ToArray();
                removedPeptides  = standardPeptides.Except(SkylineWindow.DocumentUI.Peptides.Select(nodePep => nodePep.ModifiedTarget)).ToList();
            });
            var toRemove = standardPeptides.Except(removedPeptides).ToArray();

            if (numPeptides > toRemove.Length)
            {
                Assert.Fail("Not enough peptides to remove");
            }

            for (var i = 0; i < numPeptides; i++)
            {
                RemovePeptide(toRemove[i]);
                removedPeptides.Add(toRemove[i]);
            }

            if (!removedPeptides.Any())
            {
                var importResultsDlg = ShowDialog <ImportResultsDlg>(SkylineWindow.ImportResults);
                OkDialog(importResultsDlg, importResultsDlg.CancelDialog);
                return;
            }

            var docCount = standardPeptides.Length - removedPeptides.Count;

            if (docCount >= RCalcIrt.MinStandardCount(standardPeptides.Length))
            {
                var allowedMissing = docCount - RCalcIrt.MinStandardCount(standardPeptides.Length);
                var warningDlg     = ShowDialog <MultiButtonMsgDlg>(SkylineWindow.ImportResults);
                RunUI(() =>
                {
                    foreach (var pep in removedPeptides)
                    {
                        Assert.IsTrue(warningDlg.Message.Contains(pep.ToString()));
                    }
                    Assert.IsTrue(warningDlg.Message.Contains(
                                      string.Format(Resources.SkylineWindow_ImportResults_The_document_contains__0__of_these_iRT_standard_peptides_, docCount)));
                    Assert.IsTrue(warningDlg.Message.Contains(
                                      allowedMissing > 0
                            ? string.Format(Resources.SkylineWindow_ImportResults_A_maximum_of__0__may_be_missing_and_or_outliers_for_a_successful_import_, allowedMissing)
                            : Resources.SkylineWindow_ImportResults_None_may_be_missing_or_outliers_for_a_successful_import_));
                });
                OkDialog(warningDlg, warningDlg.BtnCancelClick);
            }
            else
            {
                var errorDlg = ShowDialog <MessageDlg>(SkylineWindow.ImportResults);
                RunUI(() =>
                {
                    foreach (var pep in removedPeptides)
                    {
                        Assert.IsTrue(errorDlg.Message.Contains(pep.ToString()));
                    }
                    Assert.IsTrue(errorDlg.Message.Contains(
                                      docCount > 0
                            ? string.Format(Resources.SkylineWindow_ImportResults_The_document_only_contains__0__of_these_iRT_standard_peptides_, docCount)
                            : Resources.SkylineWindow_ImportResults_The_document_does_not_contain_any_of_these_iRT_standard_peptides_));
                    Assert.IsTrue(errorDlg.Message.Contains(Resources.SkylineWindow_ImportResults_Add_missing_iRT_standard_peptides_to_your_document_or_change_the_retention_time_predictor_));
                });
                OkDialog(errorDlg, errorDlg.OkDialog);
            }
        }