public RemoteChromDataProvider(SrmDocument document, IRetentionTimePredictor retentionTimePredictor, ChromFileInfo chromFileInfo, ProgressStatus progressStatus, int startPercent, int endPercent, ILoadMonitor loader) : base(chromFileInfo, progressStatus, startPercent, endPercent, loader) { _document = document; ChorusUrl chorusUrl = (ChorusUrl)chromFileInfo.FilePath; _chorusAccount = chorusUrl.FindChorusAccount(Settings.Default.ChorusAccountList); var chromatogramRequestProviders = new List<ChromatogramRequestProvider>(); foreach (bool firstPass in new[] {true, false}) { if (null == retentionTimePredictor && !firstPass) { continue; } var chromatogramRequestProvider = new ChromatogramRequestProvider(document, chorusUrl, retentionTimePredictor, firstPass); if (0 == chromatogramRequestProvider.ChromKeys.Count) { continue; } chromatogramRequestProviders.Add(chromatogramRequestProvider); } _chromatogramRequestProviders = chromatogramRequestProviders.ToArray(); _chromTaskLists = new ChromTaskList[_chromatogramRequestProviders.Length]; }
public RemoteChromDataProvider(SrmDocument document, IRetentionTimePredictor retentionTimePredictor, ChromFileInfo chromFileInfo, IProgressStatus progressStatus, int startPercent, int endPercent, ILoadMonitor loader) : base(chromFileInfo, progressStatus, startPercent, endPercent, loader) { _document = document; ChorusUrl chorusUrl = (ChorusUrl)chromFileInfo.FilePath; _chorusAccount = chorusUrl.FindChorusAccount(Settings.Default.RemoteAccountList); var chromatogramRequestProviders = new List <ChromatogramRequestProvider>(); foreach (bool firstPass in new[] { true, false }) { if (null == retentionTimePredictor && !firstPass) { continue; } var chromatogramRequestProvider = new ChromatogramRequestProvider(document, chorusUrl, retentionTimePredictor, firstPass); if (0 == chromatogramRequestProvider.ChromKeys.Count) { continue; } chromatogramRequestProviders.Add(chromatogramRequestProvider); } _chromatogramRequestProviders = chromatogramRequestProviders.ToArray(); _chromTaskLists = new ChromTaskList[_chromatogramRequestProviders.Length]; }
/// <summary> /// Calculate the predicted NETs of the evidences /// </summary> /// <param name="predictor">Retention Time Predictor</param> /// <param name="evidences">Evidences to process</param> /// <remarks> /// For each evidence, it passes the clean peptide sequence through the peptideCache alongside /// the predictor to determine the predicted NET. If the peptide has been seen before, it has /// already been added into a dictionary and so it simply looks up the relevant NET for the /// peptide and returns that. Otherwise, it passes the peptide through the predictor's /// GetElutionTime method, adds that value to the peptide cache with the sequence as the key /// so that if it is seen again it will get the value faster. /// </remarks> public void CalculatePredictedNet(IRetentionTimePredictor predictor, IEnumerable <Evidence> evidences) { Parallel.ForEach(evidences, evidence => { evidence.PredictedNet = ComputePeptideNET(evidence.CleanPeptide, predictor); }); }
/// <summary> /// Displays the selected dataset. /// </summary> private void ShowSelectedDataset() { try { Analysis analysis = GetSelectedAnalysis(); if (analysis != null) { m_selectedAnalysis = analysis; // If the analysis has not been processed, then do so... if (analysis.ProcessedState != ProcessingState.Processed) { //LockUserInterface(true); IRetentionTimePredictor predictor = RetentionTimePredictorFactory.CreatePredictor(m_options.PredictorType); m_processor.ProcessAnalysisJob(analysis, m_options, predictor); } else { ctlChartScanVsNET.SeriesCollection.Clear(); DisplayScansVsNet(analysis); } } else { OnStatus("No analysis was selected."); } } catch (Exception ex) { OnStatus(ex.Message); } }
public ChromatogramRequestProvider(SrmDocument srmDocument, ChorusUrl chorusUrl, IRetentionTimePredictor retentionTimePredictor, bool firstPass) { _srmDocument = srmDocument; _chorusUrl = chorusUrl; _retentionTimePredictor = retentionTimePredictor; _firstPass = firstPass; // Create a SpectrumFilter without an IRetentionTimeProvider in order to get the list of ChromKeys that we will eventually provide. SpectrumFilter spectrumFilter = new SpectrumFilter(_srmDocument, _chorusUrl, null); _chromKeys = ImmutableList.ValueOf(ListChromKeys(GetChromatogramRequestDocument(spectrumFilter))); }
/// <summary> /// Calculate the predicted NET of a single peptide /// </summary> /// <param name="peptide"></param> /// <param name="predictor">Retention Time Predictor</param> /// <returns></returns> public double ComputePeptideNET(string peptide, IRetentionTimePredictor predictor) { double predictedNET; if (!PeptideCache.TryGetValue(peptide, out predictedNET)) { predictedNET = predictor.GetElutionTime(peptide); PeptideCache.Add(peptide, predictedNET); } return(predictedNET); }
/// <summary> /// Configure and return the appropriate Retention Time Predictor /// </summary> /// <param name="type"></param> /// <returns></returns> public static IRetentionTimePredictor CreatePredictor(RetentionTimePredictionType type) { IRetentionTimePredictor predictor = null; switch (type) { case RetentionTimePredictionType.KROKHIN: predictor = new KrokhinPredictor(); break; case RetentionTimePredictionType.KANGAS: predictor = new KangasPredictor(); break; } return(predictor); }
private bool CanSchedule(SrmDocument document, IRetentionTimePredictor retentionTimePredictor) { bool canSchedule; if (RetentionTimeFilterType.scheduling_windows == _fullScan.RetentionTimeFilterType) { canSchedule = document.Settings.PeptideSettings.Prediction.CanSchedule(document, PeptidePrediction.SchedulingStrategy.any) || null != retentionTimePredictor; } else if (RetentionTimeFilterType.ms2_ids == _fullScan.RetentionTimeFilterType) { canSchedule = true; } else { canSchedule = false; } return(canSchedule); }
public static IRetentionTimePredictor CreatePredictor(RetentionTimePredictionType type) { IRetentionTimePredictor predictor = null; switch (type) { case RetentionTimePredictionType.Krokhin: predictor = new KrokhinPredictor(); break; case RetentionTimePredictionType.Kangas: predictor = new KangasPredictor(); break; default: break; } return(predictor); }
/// <summary> /// Processes an analysis job (SEQUEST or X!Tandem) /// </summary> /// <param name="analysis">Job to process</param> /// <param name="options">Options to use for processing.</param> /// <param name="massTagDatabase">Mass tag database to update.</param> /// <returns>True if successful, false if processing failed.</returns> public void ProcessAnalysisJob(Analysis analysis, Options options, IRetentionTimePredictor predictor) { lock (m_threadpool) { bool hasAnalysis = m_threadpool.ContainsKey(analysis); if (hasAnalysis) { return; } ParameterizedThreadStart start = new ParameterizedThreadStart(ProcessAnalysisJobInternal); Thread analysisthread = new Thread(start); AnalysisJob data = new AnalysisJob(); data.Analysis = analysis; data.Options = options; data.Predictor = predictor; analysisthread.Start(data); m_threadpool.Add(analysis, analysisthread); } }
/// <summary> /// Perform target alignment /// </summary> /// <param name="evidences">Evidences to align</param> /// <param name="baseline">Baseline evidences</param> /// <returns></returns> public LinearRegressionResult AlignTargets(List <Evidence> evidences, List <Evidence> baseline) { var observed = new List <double>(); var predicted = new List <double>(); foreach (var evidence in baseline) { Predictor = RetentionTimePredictorFactory.CreatePredictor(Options.PredictorType); evidence.PredictedNet = Predictor.GetElutionTime(Evidence.CleanSequence(evidence.Sequence)); observed.Add(evidence.ObservedNet); predicted.Add(evidence.PredictedNet); } Regressor = LinearRegressorFactory.Create(Options.RegressionType); var result = Regressor.CalculateRegression(observed, predicted); foreach (var evidence in evidences) { evidence.ObservedNet = Regressor.Transform(result, evidence.ObservedNet); } return(result); }
public SpectrumFilter(SrmDocument document, MsDataFileUri msDataFileUri, IFilterInstrumentInfo instrumentInfo, IRetentionTimePredictor retentionTimePredictor = null, bool firstPass = false) { _fullScan = document.Settings.TransitionSettings.FullScan; _instrument = document.Settings.TransitionSettings.Instrument; _acquisitionMethod = _fullScan.AcquisitionMethod; if (instrumentInfo != null) { _isWatersFile = instrumentInfo.IsWatersFile; } IsFirstPass = firstPass; var comparer = PrecursorTextId.PrecursorTextIdComparerInstance; var dictPrecursorMzToFilter = new SortedDictionary <PrecursorTextId, SpectrumFilterPair>(comparer); if (EnabledMs || EnabledMsMs) { if (EnabledMs) { _isHighAccMsFilter = !Equals(_fullScan.PrecursorMassAnalyzer, FullScanMassAnalyzerType.qit); if (!firstPass) { var key = new PrecursorTextId(SignedMz.ZERO, null, ChromExtractor.summed); // TIC dictPrecursorMzToFilter.Add(key, new SpectrumFilterPair(key, PeptideDocNode.UNKNOWN_COLOR, dictPrecursorMzToFilter.Count, _instrument.MinTime, _instrument.MaxTime, null, null, 0, _isHighAccMsFilter, _isHighAccProductFilter)); key = new PrecursorTextId(SignedMz.ZERO, null, ChromExtractor.base_peak); // BPC dictPrecursorMzToFilter.Add(key, new SpectrumFilterPair(key, PeptideDocNode.UNKNOWN_COLOR, dictPrecursorMzToFilter.Count, _instrument.MinTime, _instrument.MaxTime, null, null, 0, _isHighAccMsFilter, _isHighAccProductFilter)); } } if (EnabledMsMs) { _isHighAccProductFilter = !Equals(_fullScan.ProductMassAnalyzer, FullScanMassAnalyzerType.qit); if (_fullScan.AcquisitionMethod == FullScanAcquisitionMethod.DIA && _fullScan.IsolationScheme.IsAllIons) { if (instrumentInfo != null) { _isWatersMse = _isWatersFile; _isAgilentMse = instrumentInfo.IsAgilentFile; } _mseLevel = 1; } } Func <double, double> calcWindowsQ1 = _fullScan.GetPrecursorFilterWindow; Func <double, double> calcWindowsQ3 = _fullScan.GetProductFilterWindow; _minTime = _instrument.MinTime; _maxTime = _instrument.MaxTime; bool canSchedule = CanSchedule(document, retentionTimePredictor); // TODO: Figure out a way to turn off time sharing on first SIM scan so that // times can be shared for MS1 without SIM scans _isSharedTime = !canSchedule; // If we're using bare measured drift times from spectral libraries, go get those now var libraryIonMobilityInfo = document.Settings.PeptideSettings.Prediction.UseLibraryDriftTimes ? document.Settings.GetIonMobilities(msDataFileUri) : null; foreach (var nodePep in document.Molecules) { if (firstPass && !retentionTimePredictor.IsFirstPassPeptide(nodePep)) { continue; } foreach (TransitionGroupDocNode nodeGroup in nodePep.Children) { if (nodeGroup.Children.Count == 0) { continue; } double? minTime = _minTime, maxTime = _maxTime; double? startDriftTimeMsec = null, endDriftTimeMsec = null; double windowDT; double highEnergyDriftTimeOffsetMsec = 0; DriftTimeInfo centerDriftTime = document.Settings.PeptideSettings.Prediction.GetDriftTime( nodePep, nodeGroup, libraryIonMobilityInfo, out windowDT); if (centerDriftTime.DriftTimeMsec(false).HasValue) { startDriftTimeMsec = centerDriftTime.DriftTimeMsec(false) - windowDT / 2; // Get the low energy drift time endDriftTimeMsec = startDriftTimeMsec + windowDT; highEnergyDriftTimeOffsetMsec = centerDriftTime.HighEnergyDriftTimeOffsetMsec; } if (canSchedule) { if (RetentionTimeFilterType.scheduling_windows == _fullScan.RetentionTimeFilterType) { double?centerTime = null; double windowRT = 0; if (retentionTimePredictor != null) { centerTime = retentionTimePredictor.GetPredictedRetentionTime(nodePep); } else { var prediction = document.Settings.PeptideSettings.Prediction; if (prediction.RetentionTime == null || !prediction.RetentionTime.IsAutoCalculated) { centerTime = document.Settings.PeptideSettings.Prediction.PredictRetentionTimeForChromImport( document, nodePep, nodeGroup, out windowRT); } } // Force the center time to be at least zero if (centerTime.HasValue && centerTime.Value < 0) { centerTime = 0; } if (_fullScan.RetentionTimeFilterLength != 0) { windowRT = _fullScan.RetentionTimeFilterLength * 2; } if (centerTime != null) { double startTime = centerTime.Value - windowRT / 2; double endTime = startTime + windowRT; minTime = Math.Max(minTime ?? 0, startTime); maxTime = Math.Min(maxTime ?? double.MaxValue, endTime); } } else if (RetentionTimeFilterType.ms2_ids == _fullScan.RetentionTimeFilterType) { var times = document.Settings.GetBestRetentionTimes(nodePep, msDataFileUri); if (times.Length > 0) { minTime = Math.Max(minTime ?? 0, times.Min() - _fullScan.RetentionTimeFilterLength); maxTime = Math.Min(maxTime ?? double.MaxValue, times.Max() + _fullScan.RetentionTimeFilterLength); } } } SpectrumFilterPair filter; string textId = nodePep.RawTextId; // Modified Sequence for peptides, or some other string for custom ions var mz = new SignedMz(nodeGroup.PrecursorMz, nodeGroup.PrecursorCharge < 0); var key = new PrecursorTextId(mz, textId, ChromExtractor.summed); if (!dictPrecursorMzToFilter.TryGetValue(key, out filter)) { filter = new SpectrumFilterPair(key, nodePep.Color, dictPrecursorMzToFilter.Count, minTime, maxTime, startDriftTimeMsec, endDriftTimeMsec, highEnergyDriftTimeOffsetMsec, _isHighAccMsFilter, _isHighAccProductFilter); dictPrecursorMzToFilter.Add(key, filter); } if (!EnabledMs) { filter.AddQ3FilterValues(from TransitionDocNode nodeTran in nodeGroup.Children select nodeTran.Mz, calcWindowsQ3); } else if (!EnabledMsMs) { filter.AddQ1FilterValues(GetMS1MzValues(nodeGroup), calcWindowsQ1); } else { filter.AddQ1FilterValues(GetMS1MzValues(nodeGroup), calcWindowsQ1); filter.AddQ3FilterValues(from TransitionDocNode nodeTran in nodeGroup.Children where !nodeTran.IsMs1 select nodeTran.Mz, calcWindowsQ3); } } } _filterMzValues = dictPrecursorMzToFilter.Values.ToArray(); var listChromKeyFilterIds = new List <ChromKey>(); foreach (var spectrumFilterPair in _filterMzValues) { spectrumFilterPair.AddChromKeys(listChromKeyFilterIds); } _productChromKeys = listChromKeyFilterIds.ToArray(); // Sort a copy of the filter pairs by maximum retention time so that we can detect when // filters are no longer active. _filterRTValues = new SpectrumFilterPair[_filterMzValues.Length]; Array.Copy(_filterMzValues, _filterRTValues, _filterMzValues.Length); Array.Sort(_filterRTValues, CompareByRT); } InitRTLimits(); }
/// <summary> /// Processes a list of dataset objects and returns a MTDB. /// </summary> private MassTagDatabase CreateDatabaseInternal( Options options, List <Analysis> analysisDescriptions) { MassTagDatabase massTagDatabase = new MassTagDatabase(); IRetentionTimePredictor predictor = RetentionTimePredictorFactory.CreatePredictor(options.PredictorType); bool success = true; // Analyze each of the datasets, putting the results into the mass tag database // To expedite this process, only analyze if the analysis has not already been processed. int analysisNumber = 1; foreach (Analysis analysis in analysisDescriptions) { try { if (analysis.ProcessedState != ProcessingState.Processed) { ProcessAnalysisJobInternal(analysis, options, predictor); } massTagDatabase.AddResults(analysis.Targets, options.Regression, predictor); massTagDatabase.AddMetaData(analysis); GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); GC.WaitForPendingFinalizers(); if (AnalysisCompleted != null) { AnalysisCompleted(this, new AnalysisCompletedEventArgs(analysisNumber++, analysisDescriptions.Count, analysis)); } } catch (IOException ex) { analysis.ProcessedState = ProcessingState.NotProcessed; success = false; OnError(string.Format("Failed to open the analysis file {0} - {1}", analysis.FilePath, ex.Message)); break; } catch (AnalysisToolException ex) { analysis.ProcessedState = ProcessingState.NotProcessed; success = false; OnError(string.Format("The analysis failed for {0} - {1}", analysis.Name, ex.Message)); break; } catch (Exception ex) { analysis.ProcessedState = ProcessingState.NotProcessed; success = false; OnError(string.Format("The analysis failed for {0} - {1}", analysis.Name, ex.Message)); break; } } if (success) { massTagDatabase.FinalizeDatabase(); } else { massTagDatabase = null; if (this.AnalysisFailed != null) { AnalysisFailed(this, new DatabaseCreatedEventArgs(null)); } } return(massTagDatabase); }
private void ProcessAnalysisJobInternal(Analysis analysis, Options options, IRetentionTimePredictor predictor) { analysis.ProcessedState = ProcessingState.Processing; if (this.ProcessingAnalysis != null) { ProcessingAnalysis(this, new AnalysisCompletedEventArgs(1, 1, analysis)); } IAnalysisReader reader = SequenceAnalysisToolsFactory.CreateReader(analysis.Tool); ITargetFilter filter = TargetFilterFactory.CreateFilters(analysis.Tool, options); IRegressionAlgorithm regressor = RegressorFactory.CreateRegressor(RegressorType.LcmsRegressor, options.Regression); Analysis results = reader.Read(analysis.FilePath, analysis.Name); List <Target> targets = new List <Target>(); Dictionary <string, Protein> proteins = new Dictionary <string, Protein>(); foreach (var target in results.Targets) { if (options.ShouldFilter(target)) { continue; } targets.Add(target); foreach (var protein in target.Proteins) { if (!proteins.ContainsKey(protein.Reference)) { analysis.Proteins.Add(protein); proteins.Add(protein.Reference, protein); } } } analysis.AddTargets(targets); // Calculate the regression based on the target data List <float> predicted = new List <float>(); List <float> scans = new List <float>(); int maxScan = 0; int minScan = 0; foreach (Target target in analysis.Targets) { // Filter the target here...based on use for alignment. if (filter.ShouldFilter(target)) { continue; } maxScan = Math.Max(maxScan, target.Scan); minScan = Math.Min(minScan, target.Scan); target.IsPredicted = true; target.NetPredicted = predictor.GetElutionTime(target.CleanSequence); scans.Add(target.Scan); predicted.Add(Convert.ToSingle(target.NetPredicted)); } analysis.RegressionResults = regressor.CalculateRegression(scans, predicted); //analysis.RegressionResults.Regressor = regressor; analysis.RegressionResults.MinScan = minScan; analysis.RegressionResults.MaxScan = maxScan; // Make the regression line data. int scan = 0; int delta = 5; while (scan <= maxScan) { double y = regressor.GetTransformedNET(scan); scan += delta; analysis.RegressionResults.XValues.Add(Convert.ToDouble(scan)); analysis.RegressionResults.YValues.Add(y); } // Then make sure we align all against the predicted self regressor.ApplyTransformation(analysis.Targets); analysis.ProcessedState = ProcessingState.Processed; }
/// <summary> /// Adds a list of mass tags to the database. /// </summary> /// <param name="targets"></param> /// <param name="predictor"></param> private void AddMassTags(List <Target> targets, IRetentionTimePredictor predictor) { foreach (Target target in targets) { string peptideWithMod = target.Sequence + target.SequenceData.ModificationDescription; double highNorm = target.HighNormalizedScore; // Here we see if the mass tag has already been added to the database // If it has then update the tag's data if appropriate for the max values. if (m_massTagMap.ContainsKey(peptideWithMod)) { ConsensusTarget consensusTarget = m_massTagMap[peptideWithMod]; if (consensusTarget.HighNormalizedScore < highNorm) { consensusTarget.HighNormalizedScore = highNorm; } if (consensusTarget.LogEValue > target.LogPeptideEValue) { consensusTarget.LogEValue = target.LogPeptideEValue; } // Map the proteins target.Proteins.ForEach(x => consensusTarget.AddProtein(x)); target.ParentTarget = consensusTarget; consensusTarget.Targets.Add(target); // Increment the number of observations consensusTarget.NumberOfObservations++; } else { // Otherwise we create a new mass tag entry into the database. ConsensusTarget consensusTarget = new ConsensusTarget(); consensusTarget.MonoisotopicMass = target.MonoisotopicMass - (target.Charge * ConsensusTarget.PROTON_MASS); consensusTarget.Id = m_massTags.Count; consensusTarget.LogEValue = target.LogPeptideEValue; consensusTarget.HighNormalizedScore = highNorm; consensusTarget.NumberOfObservations = 1; consensusTarget.ModificationCount = target.SequenceData.ModificationCount; consensusTarget.ModificationDescription = target.SequenceData.ModificationDescription; consensusTarget.MultipleProteins = target.MultiProteinCount; consensusTarget.PmtQualityScore = 0; consensusTarget.Sequence = target.Sequence; try { consensusTarget.CleanSequence = Target.CleanPeptide(consensusTarget.Sequence); } catch (Exception ex) { int x = 9; x++; if (x < 8) { } } consensusTarget.NetPredicted = predictor.GetElutionTime(target.CleanSequence); consensusTarget.PeptideObservationCountPassingFilter = 0; consensusTarget.Targets.Add(target); // Then link the child target to these parents target.ParentTarget = consensusTarget; m_massTags.Add(consensusTarget); m_massTagMap.Add(peptideWithMod, consensusTarget); } } foreach (var consensusTarget in m_massTags) { Dictionary <string, Protein> proteins = new Dictionary <string, Protein>(); foreach (var target in consensusTarget.Targets) { foreach (var protein in target.Proteins) { if (!proteins.ContainsKey(protein.Reference)) { consensusTarget.AddProtein(protein); } } } } }
/// <summary> /// Adds a list of peptide results to the database. /// </summary> /// <param name="peptides"></param> /// <param name="type"></param> public void AddResults(List <Target> targets, RegressionTypeIdentifier type, IRetentionTimePredictor predictor) { AddMassTags(targets, predictor); }
private bool CanSchedule(SrmDocument document, IRetentionTimePredictor retentionTimePredictor) { bool canSchedule; if (RetentionTimeFilterType.scheduling_windows == _fullScan.RetentionTimeFilterType) { canSchedule = document.Settings.PeptideSettings.Prediction.CanSchedule(document, PeptidePrediction.SchedulingStrategy.any) || null != retentionTimePredictor; } else if (RetentionTimeFilterType.ms2_ids == _fullScan.RetentionTimeFilterType) { canSchedule = true; } else { canSchedule = false; } return canSchedule; }
public SpectraChromDataProvider(MsDataFileImpl dataFile, ChromFileInfo fileInfo, SrmDocument document, IRetentionTimePredictor retentionTimePredictor, string cachePath, // We'll write tempfiles in this directory ProgressStatus status, int startPercent, int endPercent, IProgressMonitor loader) : base(fileInfo, status, startPercent, endPercent, loader) { _document = document; _filePath = dataFile.FilePath; _cachePath = cachePath; // If no SRM spectra, then full-scan filtering must be enabled _isSrm = dataFile.HasSrmSpectra; if (!_isSrm) { if (!document.Settings.TransitionSettings.FullScan.IsEnabled) throw new NoFullScanFilteringException(dataFile.FilePath); // Only use the retention time predictor on non-SRM data, and only when // there are enough transitions to cause performance issues with extracting // full-gradient in a single pass, and then trimming. if (_document.Settings.TransitionSettings.FullScan.RetentionTimeFilterType == RetentionTimeFilterType.scheduling_windows && _document.MoleculeTransitionCount > MAX_FULL_GRADIENT_TRANSITIONS) { _retentionTimePredictor = retentionTimePredictor; } } // Only mzXML from mzWiff requires the introduction of zero values // during interpolation. _isProcessedScans = dataFile.IsMzWiffXml; UpdatePercentComplete(); // Create the filter responsible for chromatogram extraction bool firstPass = (_retentionTimePredictor != null); _filter = new SpectrumFilter(_document, FileInfo.FilePath, new DataFileInstrumentInfo(dataFile), _retentionTimePredictor, firstPass); if (!_isSrm && (_filter.EnabledMs || _filter.EnabledMsMs)) { // Full-scan filtering should always match a single precursor // m/z value to a single precursor node in the document tree, // because that is the way the filters are constructed in the // first place. _isSingleMzMatch = true; } // Get data object used to graph all of the chromatograms. if (_loader.HasUI) _allChromData = LoadingStatus.Transitions; try { InitSpectrumReader(dataFile); InitChromatogramExtraction(); } catch(Exception) { // If exception thrown before construction is complete than Dispose will not be called. if (_spectra == null) dataFile.Dispose(); else _spectra.Dispose(); throw; } }
public SpectrumFilter(SrmDocument document, MsDataFileUri msDataFileUri, IFilterInstrumentInfo instrumentInfo, IRetentionTimePredictor retentionTimePredictor = null, bool firstPass = false) { _fullScan = document.Settings.TransitionSettings.FullScan; _instrument = document.Settings.TransitionSettings.Instrument; _acquisitionMethod = _fullScan.AcquisitionMethod; if (instrumentInfo != null) _isWatersFile = instrumentInfo.IsWatersFile; IsFirstPass = firstPass; var comparer = PrecursorTextId.PrecursorTextIdComparerInstance; var dictPrecursorMzToFilter = new SortedDictionary<PrecursorTextId, SpectrumFilterPair>(comparer); if (EnabledMs || EnabledMsMs) { if (EnabledMs) { _isHighAccMsFilter = !Equals(_fullScan.PrecursorMassAnalyzer, FullScanMassAnalyzerType.qit); if (!firstPass) { var key = new PrecursorTextId(0, null, ChromExtractor.summed); // TIC dictPrecursorMzToFilter.Add(key, new SpectrumFilterPair(key, PeptideDocNode.UNKNOWN_COLOR, dictPrecursorMzToFilter.Count, _instrument.MinTime, _instrument.MaxTime, null, null, 0, _isHighAccMsFilter, _isHighAccProductFilter)); key = new PrecursorTextId(0, null, ChromExtractor.base_peak); // BPC dictPrecursorMzToFilter.Add(key, new SpectrumFilterPair(key, PeptideDocNode.UNKNOWN_COLOR, dictPrecursorMzToFilter.Count, _instrument.MinTime, _instrument.MaxTime, null, null, 0, _isHighAccMsFilter, _isHighAccProductFilter)); } } if (EnabledMsMs) { _isHighAccProductFilter = !Equals(_fullScan.ProductMassAnalyzer, FullScanMassAnalyzerType.qit); if (_fullScan.AcquisitionMethod == FullScanAcquisitionMethod.DIA && _fullScan.IsolationScheme.IsAllIons) { if (instrumentInfo != null) { _isWatersMse = _isWatersFile; _isAgilentMse = instrumentInfo.IsAgilentFile; } _mseLevel = 1; } } Func<double, double> calcWindowsQ1 = _fullScan.GetPrecursorFilterWindow; Func<double, double> calcWindowsQ3 = _fullScan.GetProductFilterWindow; _minTime = _instrument.MinTime; _maxTime = _instrument.MaxTime; bool canSchedule = CanSchedule(document, retentionTimePredictor); // TODO: Figure out a way to turn off time sharing on first SIM scan so that // times can be shared for MS1 without SIM scans _isSharedTime = !canSchedule; // If we're using bare measured drift times from spectral libraries, go get those now var libraryIonMobilityInfo = document.Settings.PeptideSettings.Prediction.UseLibraryDriftTimes ? document.Settings.GetIonMobilities(msDataFileUri) : null; foreach (var nodePep in document.Molecules) { if (firstPass && !retentionTimePredictor.IsFirstPassPeptide(nodePep)) continue; foreach (TransitionGroupDocNode nodeGroup in nodePep.Children) { if (nodeGroup.Children.Count == 0) continue; double? minTime = _minTime, maxTime = _maxTime; double? startDriftTimeMsec = null, endDriftTimeMsec = null; double windowDT; double highEnergyDriftTimeOffsetMsec = 0; DriftTimeInfo centerDriftTime = document.Settings.PeptideSettings.Prediction.GetDriftTime( nodePep, nodeGroup, libraryIonMobilityInfo, out windowDT); if (centerDriftTime.DriftTimeMsec(false).HasValue) { startDriftTimeMsec = centerDriftTime.DriftTimeMsec(false) - windowDT / 2; // Get the low energy drift time endDriftTimeMsec = startDriftTimeMsec + windowDT; highEnergyDriftTimeOffsetMsec = centerDriftTime.HighEnergyDriftTimeOffsetMsec; } if (canSchedule) { if (RetentionTimeFilterType.scheduling_windows == _fullScan.RetentionTimeFilterType) { double? centerTime = null; double windowRT = 0; if (retentionTimePredictor != null) { centerTime = retentionTimePredictor.GetPredictedRetentionTime(nodePep); } else { var prediction = document.Settings.PeptideSettings.Prediction; if (prediction.RetentionTime == null || !prediction.RetentionTime.IsAutoCalculated) { centerTime = document.Settings.PeptideSettings.Prediction.PredictRetentionTimeForChromImport( document, nodePep, nodeGroup, out windowRT); } } // Force the center time to be at least zero if (centerTime.HasValue && centerTime.Value < 0) centerTime = 0; if (_fullScan.RetentionTimeFilterLength != 0) { windowRT = _fullScan.RetentionTimeFilterLength * 2; } if (centerTime != null) { double startTime = centerTime.Value - windowRT / 2; double endTime = startTime + windowRT; minTime = Math.Max(minTime ?? 0, startTime); maxTime = Math.Min(maxTime ?? double.MaxValue, endTime); } } else if (RetentionTimeFilterType.ms2_ids == _fullScan.RetentionTimeFilterType) { var times = document.Settings.GetBestRetentionTimes(nodePep, msDataFileUri); if (times.Length > 0) { minTime = Math.Max(minTime ?? 0, times.Min() - _fullScan.RetentionTimeFilterLength); maxTime = Math.Min(maxTime ?? double.MaxValue, times.Max() + _fullScan.RetentionTimeFilterLength); } } } SpectrumFilterPair filter; string textId = nodePep.RawTextId; // Modified Sequence for peptides, or some other string for custom ions double mz = nodeGroup.PrecursorMz; var key = new PrecursorTextId(mz, textId, ChromExtractor.summed); if (!dictPrecursorMzToFilter.TryGetValue(key, out filter)) { filter = new SpectrumFilterPair(key, nodePep.Color, dictPrecursorMzToFilter.Count, minTime, maxTime, startDriftTimeMsec, endDriftTimeMsec, highEnergyDriftTimeOffsetMsec, _isHighAccMsFilter, _isHighAccProductFilter); dictPrecursorMzToFilter.Add(key, filter); } if (!EnabledMs) { filter.AddQ3FilterValues(from TransitionDocNode nodeTran in nodeGroup.Children select nodeTran.Mz, calcWindowsQ3); } else if (!EnabledMsMs) { filter.AddQ1FilterValues(GetMS1MzValues(nodeGroup), calcWindowsQ1); } else { filter.AddQ1FilterValues(GetMS1MzValues(nodeGroup), calcWindowsQ1); filter.AddQ3FilterValues(from TransitionDocNode nodeTran in nodeGroup.Children where !nodeTran.IsMs1 select nodeTran.Mz, calcWindowsQ3); } } } _filterMzValues = dictPrecursorMzToFilter.Values.ToArray(); var listChromKeyFilterIds = new List<ChromKey>(); foreach (var spectrumFilterPair in _filterMzValues) { spectrumFilterPair.AddChromKeys(listChromKeyFilterIds); } _productChromKeys = listChromKeyFilterIds.ToArray(); // Sort a copy of the filter pairs by maximum retention time so that we can detect when // filters are no longer active. _filterRTValues = new SpectrumFilterPair[_filterMzValues.Length]; Array.Copy(_filterMzValues, _filterRTValues, _filterMzValues.Length); Array.Sort(_filterRTValues, CompareByRT); } InitRTLimits(); }