public void GetDriftTimesFromResults()
 {
     try
     {
         var driftTable             = new MeasuredDriftTimeTable(gridMeasuredDriftTimes);
         var tempDriftTimePredictor = new DriftTimePredictor("tmp", driftTable.GetTableMeasuredDriftTimes(cbOffsetHighEnergySpectra.Checked), null, null, 30); // Not L10N
         using (var longWaitDlg = new LongWaitDlg
         {
             Text = Resources.EditDriftTimePredictorDlg_btnGenerateFromDocument_Click_Finding_drift_time_values_for_peaks,
             Message = string.Empty,
             ProgressValue = 0
         })
         {
             longWaitDlg.PerformWork(this, 100, broker =>
             {
                 tempDriftTimePredictor = tempDriftTimePredictor.ChangeMeasuredDriftTimesFromResults(Program.MainWindow.Document, Program.MainWindow.DocumentFilePath, broker);
             });
             if (!longWaitDlg.IsCanceled && tempDriftTimePredictor != null)
             {
                 UpdateMeasuredDriftTimesControl(tempDriftTimePredictor);
             }
         }
     }
     catch (Exception ex)
     {
         MessageDlg.ShowException(this, ex);
     }
 }
 private void UpdateMeasuredDriftTimesControl(DriftTimePredictor predictor)
 {
     // List any measured drift times
     gridMeasuredDriftTimes.Rows.Clear();
     if (predictor.MeasuredDriftTimePeptides != null)
     {
         bool hasHighEnergyOffsets =
             predictor.MeasuredDriftTimePeptides.Any(p => p.Value.HighEnergyDriftTimeOffsetMsec != 0);
         cbOffsetHighEnergySpectra.Checked = hasHighEnergyOffsets;
         foreach (var p in predictor.MeasuredDriftTimePeptides)
         {
             if (hasHighEnergyOffsets)
             {
                 gridMeasuredDriftTimes.Rows.Add(p.Key.Sequence,
                                                 p.Key.Charge.ToString(LocalizationHelper.CurrentCulture),
                                                 (p.Value.DriftTimeMsec(false) ?? 0).ToString(LocalizationHelper.CurrentCulture),
                                                 p.Value.HighEnergyDriftTimeOffsetMsec.ToString(LocalizationHelper.CurrentCulture)
                                                 );
             }
             else
             {
                 gridMeasuredDriftTimes.Rows.Add(p.Key.Sequence,
                                                 p.Key.Charge.ToString(LocalizationHelper.CurrentCulture),
                                                 (p.Value.DriftTimeMsec(false) ?? 0).ToString(LocalizationHelper.CurrentCulture)
                                                 );
             }
         }
     }
     else
     {
         cbOffsetHighEnergySpectra.Checked = false;
     }
 }
示例#3
0
        /// <summary>
        /// Write XML representation, possibly in backward compatible format using
        /// old style in-document serialization
        /// </summary>
        public void WriteXml(XmlWriter writer, IonMobilityWindowWidthCalculator extraInfoForPre20_12)
        {
            if (extraInfoForPre20_12 == null)
            {
                WriteXml(writer);
                return;
            }

            // Write the contents of the currently-in-use .imsdb to old style in-document serialization
            var libKeyMap = GetIonMobilityLibKeyMap();

            if (libKeyMap == null)
            {
                return;
            }
            var dict = libKeyMap.AsDictionary();

            if (dict != null && dict.Any())
            {
                var oldDict =
                    dict.ToDictionary(kvp => kvp.Key,
                                      kvp => kvp.Value.First()); // No multiple conformers in earlier formats
                var dtp = new DriftTimePredictor(Name,
                                                 oldDict, extraInfoForPre20_12.WindowWidthMode, extraInfoForPre20_12.ResolvingPower,
                                                 extraInfoForPre20_12.PeakWidthAtIonMobilityValueZero,
                                                 extraInfoForPre20_12.PeakWidthAtIonMobilityValueMax,
                                                 extraInfoForPre20_12.FixedWindowWidth);
                writer.WriteStartElement(DriftTimePredictor.EL.predict_drift_time); // N.B. EL.predict_drift_time is a misnomer, this covers all IMS types
                dtp.WriteXml(writer);
                writer.WriteEndElement();
            }
        }
示例#4
0
 /// <summary>
 /// Finds drift times by examining loaded results in a document.
 /// </summary>
 /// <param name="document">The document to be inspected</param>
 /// <param name="documentFilePath">Aids in locating the raw files</param>
 /// <param name="existing">If non-null, will be examined for any existing drift time measurements (which may be overwritten) </param>
 /// <param name="progressMonitor">Optional progress monitor for this potentially long operation</param>
 public DriftTimeFinder(SrmDocument document, string documentFilePath, DriftTimePredictor existing, IProgressMonitor progressMonitor)
 {
     _document = document;
     _documentFilePath = documentFilePath;
     _existing = existing;
     _currentDisplayedTransitionGroupDocNode = null;
     _progressMonitor = progressMonitor;
 }
示例#5
0
 /// <summary>
 /// Finds drift times by examining loaded results in a document.
 /// </summary>
 /// <param name="document">The document to be inspected</param>
 /// <param name="documentFilePath">Aids in locating the raw files</param>
 /// <param name="existing">If non-null, will be examined for any existing drift time measurements (which may be overwritten) </param>
 /// <param name="progressMonitor">Optional progress monitor for this potentially long operation</param>
 public DriftTimeFinder(SrmDocument document, string documentFilePath, DriftTimePredictor existing, IProgressMonitor progressMonitor)
 {
     _document         = document;
     _documentFilePath = documentFilePath;
     _existing         = existing;
     _currentDisplayedTransitionGroupDocNode = null;
     _progressMonitor = progressMonitor;
 }
        private void IonMobilityLibraryChanged()
        {
            var calc = _driverIonMobilityLibraryListComboDriver.SelectedItem;

            if (calc != null)
            {
                try
                {
                    if (_predictor != null)
                    {
                        _predictor = _predictor.ChangeLibrary(calc);
                    }
                }
                catch (Exception e)
                {
                    MessageDlg.ShowException(this, e);
                }
            }
            UpdateControls();
        }
        public void OkDialog()
        {
            var helper = new MessageBoxHelper(this);

            var driftTable = new MeasuredDriftTimeTable(gridMeasuredDriftTimes);

            var table = new ChargeRegressionTable(gridRegression);

            string name;

            if (!helper.ValidateNameTextBox(textName, out name))
            {
                return;
            }

            if (_existing.Contains(r => !ReferenceEquals(_predictor, r) && Equals(name, r.Name)))
            {
                if (MessageBox.Show(this,
                                    TextUtil.LineSeparate(string.Format(Resources.EditDriftTimePredictorDlg_OkDialog_A_drift_time_predictor_with_the_name__0__already_exists_, name),
                                                          Resources.EditDriftTimePredictorDlg_OkDialog_Do_you_want_to_change_it_),
                                    Program.Name, MessageBoxButtons.YesNo) != DialogResult.Yes)
                {
                    return;
                }
            }
            if (driftTable.GetTableMeasuredDriftTimes(cbOffsetHighEnergySpectra.Checked) == null) // Some error detected in the measured drift times table
            {
                return;
            }
            if (table.GetTableChargeRegressionLines() == null) // Some error detected in the charged regression lines table
            {
                return;
            }
            double resolvingPower;

            if (!helper.ValidateDecimalTextBox(textResolvingPower, out resolvingPower))
            {
                return;
            }

            var errmsg = ValidateResolvingPower(resolvingPower);

            if (errmsg != null)
            {
                helper.ShowTextBoxError(textResolvingPower, errmsg);
                return;
            }

            if ((comboLibrary.SelectedIndex > 0) && (comboLibrary.SelectedItem.ToString().Length == 0))
            {
                MessageBox.Show(this, Resources.EditDriftTimePredictorDlg_OkDialog_Drift_time_prediction_requires_an_ion_mobility_library_,
                                Program.Name);
                comboLibrary.Focus();
                return;
            }
            var ionMobilityLibrary = _driverIonMobilityLibraryListComboDriver.SelectedItem;

            DriftTimePredictor predictor =
                new DriftTimePredictor(name, driftTable.GetTableMeasuredDriftTimes(cbOffsetHighEnergySpectra.Checked),
                                       ionMobilityLibrary, table.GetTableChargeRegressionLines(), resolvingPower);

            _predictor = predictor;

            DialogResult = DialogResult.OK;
        }
示例#8
0
 public PeptidePrediction ChangeDriftTimePredictor(DriftTimePredictor prop)
 {
     return ChangeProp(ImClone(this), im => im.DriftTimePredictor = prop);
 }
示例#9
0
        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();
        }
示例#10
0
 public PeptidePrediction(RetentionTimeRegression retentionTime, DriftTimePredictor driftTimePredictor = null)
     : this(retentionTime, driftTimePredictor, true, DEFAULT_MEASURED_RT_WINDOW, false, null)
 {
 }