Esempio n. 1
0
        public CalibrateIrtDlg(IrtStandard standard, IEnumerable <IrtStandard> existing, DbIrtPeptide[] updatePeptides)
        {
            InitializeComponent();

            Icon = Resources.Skyline;

            _standard = standard;
            _standardPeptidesSorted = standard != null?standard.Peptides.OrderBy(pep => pep.Irt).ToArray() : new DbIrtPeptide[0];

            _existing       = existing;
            _updatePeptides = updatePeptides;

            _gridViewDriver = new CalibrationGridViewDriver(this, gridViewCalibrate, bindingSourceStandard,
                                                            new SortableBindingList <StandardPeptide>());

            FireStandardsChanged = true;

            comboRegression.Items.AddRange(RegressionOption.All(Program.ActiveDocumentUI).ToArray());
            comboRegression.SelectedIndex = 0;

            if (IsRecalibration)
            {
                textName.Text   = standard?.Name;
                FormBorderStyle = FormBorderStyle.Fixed3D;
                panelPeptides.Hide();
                btnUseCurrent.Hide();
                Height -= panelPeptides.Height;
                var standardPeptides = _standardPeptidesSorted.Select(pep => pep.PeptideModSeq).ToArray();
                comboMinPeptide.Items.AddRange(standardPeptides);
                comboMaxPeptide.Items.AddRange(standardPeptides);
                if (standardPeptides.Length > 0)
                {
                    // Look for standard peptides with whole number values as the suggested fixed points
                    var iFixed1 = _standardPeptidesSorted.IndexOf(pep => Math.Round(pep.Irt, 8) == Math.Round(pep.Irt));
                    var iFixed2 = _standardPeptidesSorted.LastIndexOf(pep => Math.Round(pep.Irt, 8) == Math.Round(pep.Irt));
                    if (iFixed1 == -1 || iFixed2 == -1)
                    {
                        iFixed1 = 0;
                        iFixed2 = _standardPeptidesSorted.Length - 1;
                    }
                    else if (iFixed1 == iFixed2)
                    {
                        if (iFixed1 < _standardPeptidesSorted.Length / 2)
                        {
                            iFixed2 = _standardPeptidesSorted.Length - 1;
                        }
                        else
                        {
                            iFixed1 = 0;
                        }
                    }
                    comboMinPeptide.SelectedIndex = iFixed1;
                    comboMaxPeptide.SelectedIndex = iFixed2;
                    SetIrtRange(_standardPeptidesSorted[iFixed1].Irt, _standardPeptidesSorted[iFixed2].Irt);
                }
            }
        }
Esempio n. 2
0
            private List <MeasuredPeptide> PickPeptides(SrmDocument doc, int count, ICollection <Target> exclude, RegressionOption currentRegression, out RegressionOption cirt)
            {
                cirt = null;

                if (!_picker.HasScoredPeptides)
                {
                    using (var longWaitDlg = new LongWaitDlg {
                        Text = Resources.CalibrationGridViewDriver_FindEvenlySpacedPeptides_Calculating_scores
                    })
                    {
                        longWaitDlg.PerformWork(_parent, 1000, pm => _picker.ScorePeptides(doc, pm));
                        if (longWaitDlg.IsCanceled)
                        {
                            return(null);
                        }
                    }
                }

                RegressionLine cirtRegression    = null;
                var            useCirt           = false;
                var            cirtUsePredefined = false;

                if (_picker.TryGetCirtRegression(count, out var tryCirtRegression, out var matchedPeptides))
                {
                    var currentIsCirt = currentRegression != null && currentRegression.IsCirtDiscovered;
                    switch (MultiButtonMsgDlg.Show(_parent, string.Format(
                                                       Resources.CalibrationGridViewDriver_FindEvenlySpacedPeptides_This_document_contains__0__CiRT_peptides__Would_you_like_to_use__1__of_them_as_your_iRT_standards_,
                                                       _picker.CirtPeptideCount, count), MultiButtonMsgDlg.BUTTON_YES, MultiButtonMsgDlg.BUTTON_NO, true))
                    {
                    case DialogResult.Yes:
                        cirtRegression = tryCirtRegression;
                        useCirt        = true;
                        if (currentRegression?.RegressionLine == null || currentIsCirt)
                        {
                            switch (MultiButtonMsgDlg.Show(_parent,
                                                           Resources.CalibrationGridViewDriver_FindEvenlySpacedPeptides_Would_you_like_to_use_the_predefined_iRT_values_,
                                                           Resources.CalibrationGridViewDriver_FindEvenlySpacedPeptides_Predefined_values,
                                                           Resources.CalibrationGridViewDriver_FindEvenlySpacedPeptides_Calculate_from_regression,
                                                           true))
                            {
                            case DialogResult.Yes:
                                cirtUsePredefined = true;
                                break;

                            case DialogResult.No:
                                break;

                            case DialogResult.Cancel:
                                return(null);
                            }
                        }
                        break;

                    case DialogResult.No:
                        if (currentIsCirt)
                        {
                            cirtRegression = tryCirtRegression;
                        }
                        break;

                    case DialogResult.Cancel:
                        return(null);
                    }
                }

                var bestPeptides = _picker.Pick(count, exclude, useCirt);

                if (cirtRegression != null)
                {
                    var standardPeptides = bestPeptides.Select(pep => new StandardPeptide
                    {
                        Irt           = cirtUsePredefined ? _picker.CirtIrt(pep.Target).Value : double.NaN,
                        RetentionTime = pep.RetentionTime,
                        Target        = pep.Target
                    }).ToList();
                    cirt = new RegressionOption(Resources.CalibrationGridViewDriver_CiRT_option_name, cirtRegression,
                                                matchedPeptides.ToList(), standardPeptides, false, false);
                }
                return(bestPeptides);
            }
Esempio n. 3
0
            public List <StandardPeptide> Recalculate(SrmDocument document, int peptideCount, RegressionOption currentRegression, ICollection <Target> exclude)
            {
                var bestPeptides = PickPeptides(document, peptideCount, exclude, currentRegression, out var cirt);

                if (bestPeptides == null)
                {
                    return(null);
                }
                if ((currentRegression?.RegressionLine != null && !currentRegression.IsCirtDiscovered) || cirt == null)
                {
                    SetPeptides(bestPeptides);
                }
                else
                {
                    var existingCirt = _parent.RegressionOptions.IndexOf(opt => opt.Name.Equals(Resources.CalibrationGridViewDriver_CiRT_option_name));
                    if (existingCirt < 0)
                    {
                        _parent.comboRegression.Items.Add(cirt);
                    }
                    else
                    {
                        _parent.comboRegression.Items[existingCirt] = cirt;
                    }
                    _parent.SelectedRegressionOption = cirt;
                }
                return(Items.ToList());
            }