private bool NextSpectrumIsAgilentMse(MsDataSpectrum nextSpectrum, int listLevel, double startCE)
 {
     // Average runs of MS/MS scans until the start CE is seen again
     return (_filter.IsAgilentMse &&
         listLevel == 2 &&
         nextSpectrum.Level == 2 &&
         startCE != GetPrecursorCollisionEnergy(nextSpectrum));
 }
Exemple #2
0
        /// <summary>
        /// generates a fake deconvolution solution for the given test spectrum
        /// in order to make sure that the deconvolution results are being applied
        /// correctly to scale peaks in the test spectrum
        /// </summary>
        private static void TestPeakIntensityCorrection(MsDataSpectrum testSpectrum,
            AbstractIsoWindowMapper isoMapper,
            AbstractDemultiplexer demultiplexer)
        {
            // Store a reference to the old spectrum processor
            var oldProcessor = demultiplexer.SpectrumProcessor;
            MsxDeconvSolverHandler db = new MsxDeconvSolverHandler(100, 120, 35);
            int[] isoIndices;
            int[] deconvIndices;
            double[] mask = new double[100];
            isoMapper.GetWindowMask(testSpectrum, out isoIndices, out deconvIndices, ref mask);
            db.SetDeconvIndices(deconvIndices);
            Assert.IsTrue(deconvIndices.Contains(50));
            Assert.IsTrue(deconvIndices.Contains(47));
            Assert.IsTrue(deconvIndices.Contains(15));
            Assert.IsTrue(deconvIndices.Contains(17));
            Assert.IsTrue(deconvIndices.Contains(74));
            Assert.AreEqual(5, deconvIndices.Length);

            // Prepare the transition binner with a precursor containing transitions overlapping
            // peaks in the test spectrum
            List<double> precursors = new List<double>();
            List<KeyValuePair<double, double>> transitions = new List<KeyValuePair<double, double>>();
            var precVals = new[] {710.57};
            var transMzs = new[] {372.18, 373.1588, 373.1794, 375.2, 379.23, 387.19};
            var transWidths = new[] {0.3, 0.04, 0.02, 1.0, 1.0, 1.0};
            foreach (var precMz in precVals)
            {
                for (int i = 0; i < isoIndices.Length; ++i)
                {
                    var transMz = transMzs[i];
                    var transWidth = transWidths[i];
                    precursors.Add(precMz);
                    transitions.Add(new KeyValuePair<double, double>(transMz, transWidth));
                }
            }

            var transBinner = new TransitionBinner(precursors, transitions, isoMapper);
            var binIndicesSet = new HashSet<int>(transBinner.BinsForDeconvWindows(deconvIndices));

            double[][] deconvIntensities = new double[deconvIndices.Length][];
            double[][] deconvMzs = new double[deconvIndices.Length][];

            for (int i = 0; i < deconvIndices.Length; ++i)
            {
                deconvIntensities[i] = new double[testSpectrum.Mzs.Length];
                deconvMzs[i] = new double[testSpectrum.Mzs.Length];
            }

            List<int> binIndicesList = binIndicesSet.ToList();
            binIndicesList.Sort();

            // Use each transition bin index to test a different possible
            // type of demultiplexed solution
            int numDeMultiplexedTrans = binIndicesSet.Count;
            double[] peakSums = new double[numDeMultiplexedTrans];
            // Initialize the deconvBlock
            db.Solution.Resize(100, binIndicesList.Count);
            db.Solution.Clear();
            // Transition index 0, each row is a precursor
            // the values for each precursor are the relative contribution
            // of that precursor to the observed (convolved) intensity of the peak
            db.Solution.Matrix[2, 0] = 0.0;
            db.Solution.Matrix[1, 0] = 0.0;
            db.Solution.Matrix[0, 0] = 0.0;
            db.Solution.Matrix[3, 0] = 0.0;
            db.Solution.Matrix[4, 0] = 0.0;
            peakSums[0] = 0.0;
            // Transition index 1, each row is a precursor
            db.Solution.Matrix[2, 1] = 1.0;
            db.Solution.Matrix[1, 1] = 1.0;
            db.Solution.Matrix[0, 1] = 2.0;
            db.Solution.Matrix[3, 1] = 1.0;
            db.Solution.Matrix[4, 1] = 1.0;
            peakSums[1] = 6.0;
            // Transition index 2, each row is a precursor
            db.Solution.Matrix[2, 2] = 2.0;
            db.Solution.Matrix[1, 2] = 1.0;
            db.Solution.Matrix[0, 2] = 3.0;
            db.Solution.Matrix[3, 2] = 3.0;
            db.Solution.Matrix[4, 2] = 1.0;
            peakSums[2] = 10.0;
            // Transition index 3, each row is a precursor
            db.Solution.Matrix[2, 3] = 0.0;
            db.Solution.Matrix[1, 3] = 0.0;
            db.Solution.Matrix[0, 3] = 1.0;
            db.Solution.Matrix[3, 3] = 0.0;
            db.Solution.Matrix[4, 3] = 0.0;
            peakSums[3] = 1.0;
            // Transition index 4, each row is a precursor
            db.Solution.Matrix[2, 4] = 1.0;
            db.Solution.Matrix[1, 4] = 1.0;
            db.Solution.Matrix[0, 4] = 1.0;
            db.Solution.Matrix[3, 4] = 1.0;
            db.Solution.Matrix[4, 4] = 1.0;
            peakSums[4] = 5.0;

            // Transition bin index (in transBinner) -> solution transition index (0-4 above), needed for
            // CorrectPeakIntensities call
            Dictionary<int, int> binToDeconvIndex = new Dictionary<int, int>(numDeMultiplexedTrans);
            int numBinIndices = binIndicesList.Count;
            for (int i = 0; i < numBinIndices; ++i)
                binToDeconvIndex[binIndicesList[i]] = i;
            var queryBinEnumerator = transBinner.BinsFromValues(testSpectrum.Mzs, true);
            demultiplexer.SpectrumProcessor = new SpectrumProcessor(165, isoMapper, transBinner);
            // Apply the peak intensity correction
            demultiplexer.CorrectPeakIntensitiesTest(testSpectrum, binIndicesSet, peakSums,
                                                     queryBinEnumerator, db, ref deconvIntensities,
                                                     ref deconvMzs);

            // Check that the five solutions defined above were applied correctly
            // by CorrectPeakIntensities

            // If all precursors contribute 0 intensity, the peak should be zero for every
            // deconvolved spectrum
            for (int i = 0; i < deconvIndices.Length; ++i)
            {
                Assert.AreEqual(deconvIntensities[i][binToDeconvIndex[0]], 0.0);
            }

            // Find the index of the demultiplexed spectrum corresponding to the precursor
            // at 710.57 m/z for which we generated the dummy demultiplexing solution for
            int windowIndex;
            isoMapper.TryGetDeconvFromMz(710.57, out windowIndex);
            Assert.AreEqual(50, windowIndex);
            int isoIndex = deconvIndices.IndexOf(i => i == windowIndex);
            Assert.AreNotEqual(-1 , isoIndex);

            // This peak falls in one transition bin (transition index 1)
            // 47 is the index of a peak in the test spectrum
            var originalIntensity = testSpectrum.Intensities[47];
            var expectedIntensity = originalIntensity*(2.0/6.0);
            Assert.AreEqual(deconvIntensities[isoIndex][47], expectedIntensity, 0.00001);

            // This peak falls in one transitions bin (transition index 2)
            originalIntensity = testSpectrum.Intensities[50];
            expectedIntensity = originalIntensity*(3.0/10.0);
            Assert.AreEqual(deconvIntensities[isoIndex][50], expectedIntensity, 0.00001);

            // This peak falls in both transition indices 1 and 2, the expected adjusted
            // intensity should be the average of the solution from each transition bin
            originalIntensity = testSpectrum.Intensities[49];
            expectedIntensity = originalIntensity*(19.0/60.0);
            Assert.AreEqual(deconvIntensities[isoIndex][49], expectedIntensity, 0.00001);

            // This peak falls in transition index 3, and the demultiplexing spectra
            // indicates that all of the intensity of teh original peak comes from
            // the precursor window at isoIndex that's being queried.  The peak intensity
            // should not change
            originalIntensity = testSpectrum.Intensities[108];
            expectedIntensity = originalIntensity;
            Assert.AreEqual(deconvIntensities[isoIndex][108], expectedIntensity, 0.00001);

            // This peak falls in one transition bin (transition index 5)
            originalIntensity = testSpectrum.Intensities[149];
            expectedIntensity = originalIntensity * (1.0/5.0);
            Assert.AreEqual(deconvIntensities[isoIndex][149], expectedIntensity, 0.00001);

            // Undo changes to the spectrum processor in case this demultiplexer object is
            // reused
            demultiplexer.SpectrumProcessor = oldProcessor;
        }
 private static double GetPrecursorCollisionEnergy(MsDataSpectrum dataSpectrum)
 {
     return dataSpectrum.Precursors.Length > 0
         ? dataSpectrum.Precursors[0].PrecursorCollisionEnergy ?? 0
         : 0;
 }
Exemple #4
0
 private static double FindMinMz(MsDataSpectrum[] spectra, int[] indices)
 {
     double minMz = double.MaxValue;
     for (int i = 0; i < indices.Length; i++)
     {
         var scan = spectra[i];
         int indexMz = indices[i];
         if (indexMz < scan.Mzs.Length)
             minMz = Math.Min(minMz, spectra[i].Mzs[indexMz]);
     }
     return minMz;
 }
Exemple #5
0
 private void SetSpectra(MsDataSpectrum[] spectra)
 {
     Invoke(new Action(() => SetSpectraUI(spectra)));
 }
        /// <summary>
        /// Process a list of spectra - typically of length one,
        /// but possibly a set of drift bins all with same retention time,
        /// or a set of Agilent ramped-CE Mse scans to be averaged
        /// </summary>
        private void ProcessSpectrumList(MsDataSpectrum[] spectra,
            ChromDataCollectorSet chromMap,
            double rt,
            SpectrumFilter filter,
            string scanId)
        {
            lock (_blockWriter)
            {
                foreach (var spectrum in filter.Extract(rt, spectra))
                {
                    if (_loader.IsCanceled)
                        throw new LoadCanceledException(Status);

                    chromMap.ProcessExtractedSpectrum((float) rt, _collectors, GetScanIdIndex(scanId), spectrum, AddChromCollector);
                }
            }
        }
 public MsDataSpectrum GetSpectrum(int index)
 {
     if (index == _lookAheadIndex)
     {
         return _lookAheadDataSpectrum ?? (_lookAheadDataSpectrum = _dataFile.GetSpectrum(index));
     }
     else
     {
         return _dataFile.GetSpectrum(index);
     }
 }
        private MsDataSpectrum GetSpectrum(Spectrum spectrum)
        {
            if (spectrum == null)
            {
                return new MsDataSpectrum
                {
                    Centroided = true,
                    Mzs = new double[0],
                    Intensities = new double[0]
                };
            }
            var msDataSpectrum = new MsDataSpectrum
            {
                Id = id.abbreviate(spectrum.id),
                Level = GetMsLevel(spectrum) ?? 0,
                Index = spectrum.index,
                RetentionTime = GetStartTime(spectrum),
                DriftTimeMsec = GetDriftTimeMsec(spectrum),
                Precursors = GetPrecursors(spectrum),
                Centroided = IsCentroided(spectrum),
            };
            if (spectrum.binaryDataArrays.Count <= 1)
            {
                msDataSpectrum.Mzs = new double[0];
                msDataSpectrum.Intensities = new double[0];
            }
            else
            {
                try
                {
                    msDataSpectrum.Mzs = ToArray(spectrum.getMZArray());
                    msDataSpectrum.Intensities = ToArray(spectrum.getIntensityArray());

                    if (msDataSpectrum.Level == 1 && _config.simAsSpectra &&
                            spectrum.scanList.scans[0].scanWindows.Count > 0)
                    {
                        msDataSpectrum.Precursors = GetMs1Precursors(spectrum);
                    }

                    return msDataSpectrum;
                }
                catch (NullReferenceException)
                {
                }
            }
            return msDataSpectrum;
        }
        public IEnumerable<ExtractedSpectrum> Extract(double? retentionTime, MsDataSpectrum[] spectra)
        {
            if (!EnabledMsMs || !retentionTime.HasValue || !spectra.Any())
                yield break;

            var handlingType = _fullScan.IsolationScheme == null || _fullScan.IsolationScheme.SpecialHandling == null
                ? IsolationScheme.SpecialHandlingType.NONE
                : _fullScan.IsolationScheme.SpecialHandling;
            bool ignoreIso = handlingType == IsolationScheme.SpecialHandlingType.OVERLAP ||
                             handlingType == IsolationScheme.SpecialHandlingType.OVERLAP_MULTIPLEXED;

            foreach (var isoWin in GetIsolationWindows(spectra[0].Precursors))
            {
                foreach (var filterPair in FindFilterPairs(isoWin, _acquisitionMethod, ignoreIso))
                {
                    if (!filterPair.ContainsRetentionTime(retentionTime.Value))
                        continue;
                    var filteredSrmSpectrum = filterPair.FilterQ3SpectrumList(spectra, _isWatersMse && GetMseLevel() > 1);
                    if (filteredSrmSpectrum != null)
                        yield return filteredSrmSpectrum;
                }
            }
        }
Exemple #10
0
 public bool TryGetSpectrum(int scanNum, out MsDataSpectrum spectrum)
 {
     return _cache.TryGetValue(scanNum, out spectrum);
 }
Exemple #11
0
 public bool IsWatersLockmassSpectrum(MsDataSpectrum s)
 {
     return _lockmassFunction.HasValue && (s.WatersFunctionNumber >= _lockmassFunction.Value);
 }
Exemple #12
0
 public void Add(int scanNum, MsDataSpectrum s)
 {
     if (_scanStack.Count() >= _cacheSize)
     {
         _cache.Remove(_scanStack.Dequeue());
     }
     _cache.Add(scanNum, s);
     _scanStack.Enqueue(scanNum);
 }
Exemple #13
0
        private static TransitionBinner TestTransitionBinnerOverlap(MsDataSpectrum spectrum, 
            AbstractIsoWindowMapper isoMapper, double[] binnedIntensities)
        {
            // Multiple transitions overlapping the same peak from the same precursor
            var precursorList = new List<double>();
            var transitionList = new List<KeyValuePair<double, double>>();
            precursorList.Add(710.5);                                 //transition: start - stop     index
            transitionList.Add(new KeyValuePair<double, double>(380.19,1.0));   // 379.69-380.69     Bin3
            precursorList.Add(710.5);
            transitionList.Add(new KeyValuePair<double, double>(380.44,1.0));   // 379.94-380.94     Bin4
            precursorList.Add(710.5);
            transitionList.Add(new KeyValuePair<double, double>(380.49,0.6));   // 380.19-380.79     Bin5
            // And a non-overlapping transition for good measure
            precursorList.Add(710.5);
            transitionList.Add(new KeyValuePair<double, double>(389.19,0.3));   // 389.04 - 389.34   Bin7
            // And a transition that won't have any peaks in the spectrum
            precursorList.Add(710.5);
            transitionList.Add(new KeyValuePair<double, double>(377.0,0.7));    // 376.65-377.35     Bin0

            // And now another precursor with some of the transitions overlapping the first
            precursorList.Add(595.0);
            transitionList.Add(new KeyValuePair<double, double>(380.0,1.0));    // 379.5 - 380.5     Bin2
            precursorList.Add(595.0);
            transitionList.Add(new KeyValuePair<double, double>(379.55,1.0));   // 379.05 - 380.05   Bin1
            precursorList.Add(595.0);
            transitionList.Add(new KeyValuePair<double, double>(389.15, 0.4));  // 388.95 - 389.35   Bin6

            var transitionBinner = new TransitionBinner(precursorList, transitionList, isoMapper);

            double[] binnedData = new double[transitionList.Count];
            transitionBinner.BinData(spectrum.Mzs, spectrum.Intensities, ref binnedData);

            // Test that m/z, intensity pairs were binned correctly into their transitions
            for (int i = 0; i< binnedData.Length; ++i)
            {
                Assert.AreEqual(binnedIntensities[i], binnedData[i], 0.001);
            }

            // Get the precursor index for this precursor
            // make sure the precursor -> transition mapping is working for the first precursor
            int windowIndexOne;
            Assert.IsTrue(isoMapper.TryGetDeconvFromMz(710.5, out windowIndexOne));
            // Use the precursor index to get the bins mapping to this precursor
            var precursorBins = new HashSet<int>(transitionBinner.BinsForDeconvWindows(new[] {windowIndexOne}));
            var expectedPrecursorBins = new HashSet<int>(new[]{0,3,4,5,7});
            var setComparer = HashSet<int>.CreateSetComparer();
            Assert.IsTrue(setComparer.Equals(expectedPrecursorBins, precursorBins));

            // Make sure the precursor -> transition mapping is working for the second precursor
            int windowIndexTwo;
            Assert.IsTrue(isoMapper.TryGetDeconvFromMz(595.0, out windowIndexTwo));
            precursorBins = new HashSet<int>(transitionBinner.BinsForDeconvWindows(new[]{windowIndexOne, windowIndexTwo}));
            expectedPrecursorBins = new HashSet<int>(new[]{0,1,2,3,4,5,6,7});
            Assert.IsTrue(setComparer.Equals(expectedPrecursorBins, precursorBins));

            // m/z values to test mapping of m/z value -> multiplex matching transition bins
            var queryVals = new[] {252.0, 377.0, 379.92, 379.95};
            var bins = transitionBinner.BinsFromValues(queryVals, true).ToList();

            var expectedBins = new List<KeyValuePair<int, int>>
                                   {
                                       new KeyValuePair<int, int>(1, 0),
                                       new KeyValuePair<int, int>(2, 1),
                                       new KeyValuePair<int, int>(2, 2),
                                       new KeyValuePair<int, int>(2, 3),
                                       new KeyValuePair<int, int>(3, 1),
                                       new KeyValuePair<int, int>(3, 2),
                                       new KeyValuePair<int, int>(3, 3),
                                       new KeyValuePair<int, int>(3, 4)
                                   };
            AssertEx.AreEqualDeep(expectedBins, bins);
            Assert.AreEqual(376.65, transitionBinner.LowerValueFromBin(0),0.0001);
            Assert.AreEqual(377.35, transitionBinner.UpperValueFromBin(0),0.0001);
            Assert.AreEqual(377.0, transitionBinner.CenterValueFromBin(0),0.0001);
            return transitionBinner;
        }
Exemple #14
0
 /// <summary> 
 /// Demultiplexes a real .mxML file in a case where the answer is simple, and checks the answer is correct.
 /// </summary>
 private static void TestSpectrumDemultiplex(AbstractDemultiplexer demultiplexer, 
     int spectrumIndex,
     MsDataSpectrum originalSpectrum,
     int[] intensityIndices,
     double[] intensityValues,
     int deconvIndex)
 {
     var deconvSpectra = demultiplexer.GetDeconvolvedSpectra(spectrumIndex, originalSpectrum);
     int numberMzPoints = originalSpectrum.Intensities.Length;
     double[] peakSums = new double[numberMzPoints];
     for (int i = 0; i < numberMzPoints; ++i)
     {
         peakSums[i] = 0.0;
     }
     foreach (var deconvSpectrum in deconvSpectra)
     {
         Assert.AreEqual(deconvSpectrum.Intensities.Length, originalSpectrum.Intensities.Length);
         for (int i = 0; i < numberMzPoints; ++i)
         {
             peakSums[i] += deconvSpectrum.Intensities[i];
         }
     }
     for (int i = 0; i < numberMzPoints; ++i)
     {
         Assert.AreEqual(peakSums[i], originalSpectrum.Intensities[i], 0.01);
     }
     for (int i = 0; i < intensityIndices.Length ; ++i)
     {
         Assert.AreEqual(deconvSpectra[deconvIndex].Intensities[intensityIndices[i]], intensityValues[i], 0.1);
     }
 }
 private bool NextSpectrumIsDriftScanForCurrentRetentionTime(MsDataSpectrum nextSpectrum)
 {
     bool result = ((_rt ?? 0) == (nextSpectrum.RetentionTime ?? -1)) &&
                   ((nextSpectrum.DriftTimeMsec ?? 0) > _previousDriftTime);
     _previousDriftTime = nextSpectrum.DriftTimeMsec ?? 0;
     return result;
 }
Exemple #16
0
 public bool IsMsSpectrum(MsDataSpectrum dataSpectrum)
 {
     if (!EnabledMs)
         return false;
     if (_mseLevel > 0)
         return UpdateMseLevel(dataSpectrum) == 1;
     return dataSpectrum.Level == 1;
 }
 public SpectrumInfo(int index, MsDataSpectrum dataSpectrum, MsDataSpectrum[] allSpectra, double retentionTime)
 {
     Index = index;
     DataSpectrum = dataSpectrum;
     AllSpectra = allSpectra;
     RetentionTime = retentionTime;
 }
Exemple #18
0
 public bool IsSimSpectrum(MsDataSpectrum dataSpectrum)
 {
     if (!EnabledMs || _mseLevel > 0)
         return false;
     return dataSpectrum.Level == 1 &&
         IsSimIsolation(GetIsolationWindows(dataSpectrum.Precursors).FirstOrDefault());
 }
 public LookaheadContext(SpectrumFilter filter, MsDataFileImpl dataFile)
 {
     _lookAheadIndex = 0;
     _lookAheadDataSpectrum = null;
     _filter = filter;
     _dataFile = dataFile;
     _rt = null;
     _previousDriftTime = 0;
     _lenSpectra = dataFile.SpectrumCount;
 }
Exemple #20
0
        public IEnumerable<ExtractedSpectrum> SrmSpectraFromMs1Scan(double? retentionTime,
            IList<MsPrecursor> precursors, MsDataSpectrum[] spectra)
        {
            if (!EnabledMs || !retentionTime.HasValue || spectra == null)
                yield break;

            // All filter pairs have a shot at filtering the MS1 scans
            bool isSimSpectra = spectra.Any(IsSimSpectrum);
            foreach (var filterPair in FindMs1FilterPairs(precursors))
            {
                if (!filterPair.ContainsRetentionTime(retentionTime.Value))
                    continue;
                var filteredSrmSpectrum = filterPair.FilterQ1SpectrumList(spectra, isSimSpectra);
                if (filteredSrmSpectrum != null)
                    yield return filteredSrmSpectrum;
            }
        }
            // Deal with ion mobility data - look ahead for a run of scans all
            // with the same retention time.  For non-IMS data we'll just get
            // a single "drift bin" with no drift time.
            //
            // Also for Agilent ramped-CE msE, gather MS2 scans together
            // so they get averaged.
            public MsDataSpectrum[] Lookahead(MsDataSpectrum dataSpectrum, out double? rt)
            {
                var spectrumList = new List<MsDataSpectrum>();
                int listLevel = dataSpectrum.Level;
                double startCE = GetPrecursorCollisionEnergy(dataSpectrum);
                _previousDriftTime = -1;
                double rtTotal = 0;
                double? rtFirst = null;
                _lookAheadDataSpectrum = null;
                while (_lookAheadIndex++ < _lenSpectra)
                {
                    _rt = dataSpectrum.RetentionTime;
                    if (_rt.HasValue && dataSpectrum.Mzs.Length != 0)
                    {
                        spectrumList.Add(dataSpectrum);
                        rtTotal += dataSpectrum.RetentionTime.Value;
                        if (!rtFirst.HasValue)
                            rtFirst = dataSpectrum.RetentionTime;
                    }
                    if (!_filter.IsAgilentMse && !dataSpectrum.DriftTimeMsec.HasValue)
                        break;

                    if (_lookAheadIndex < _lenSpectra)
                    {
                        dataSpectrum = _lookAheadDataSpectrum = _dataFile.GetSpectrum(_lookAheadIndex);
                        // Reasons to keep adding to the list:
                        //   Retention time hasn't changed but drift time has increased, or
                        //   Agilent ramped-CE data - MS2 scans get averaged
                        if (!(NextSpectrumIsDriftScanForCurrentRetentionTime(dataSpectrum) ||
                              NextSpectrumIsAgilentMse(dataSpectrum, listLevel, startCE)))
                            break;
                    }
                }
                if (spectrumList.Any()) // Should have at least one non-empty scan at this drift time
                    _rt = _filter.IsAgilentMse ? (rtTotal / spectrumList.Count()) : rtFirst;
                else
                    _rt = null;
                rt = _rt;
                return spectrumList.ToArray();
            }
Exemple #22
0
 private int UpdateMseLevel(MsDataSpectrum dataSpectrum)
 {
     int returnval;
     if ((_mseLastSpectrum == null) || !ReferenceEquals(dataSpectrum, _mseLastSpectrum)) // is this the same one we were just asked about?
     {
         // Waters MSe is enumerated in interleaved scans ("functions" in the raw data) 1==MS 2==MSMS 3=ignore
         // Bruker MSe is enumerated in interleaved MS1 and MS/MS scans
         // Agilent MSe is a series of MS1 scans with ramped CE (SpectrumList_Agilent returns these as MS1,MS2,MS2,...)
         //    but with ion mobility, as of June 2014, it's just a series of MS2 scans with a single nonzero CE, or MS1 scans with 0 CE
         if (_isAgilentMse)
         {
             if (1 == dataSpectrum.Level)
             {
                 _mseLevel = 1; // Expecting a series of MS2 scans to follow after this
                 returnval = 1; // Report as MS1
             }
             else if ((2 == dataSpectrum.Level) &&
                 (_mseLastSpectrum != null)) // Sometimes the file doesn't contain that leading MS1 scan
             {
                 _mseLevel = 2;
                 returnval = 2;
             }
             else
             {
                 returnval = 0; // Not useful - probably the file started off mid-cycle, with MS2 CE>0
             }
         }
         else if (!_isWatersMse)
         {
             // Bruker - Alternate between 1 and 2
             _mseLevel = (_mseLevel % 2) + 1;
             returnval = _mseLevel;
         }
         else
         {
             // Waters - mse level 1 in raw data "function 1", mse level 2 in raw data "function 2", and "function 3" which we ignore (lockmass?)
             // All are declared mslevel=1, but we can tell these apart by inspecting the Id which is formatted as <function>.<process>.<scan>
             _mseLevel = int.Parse(dataSpectrum.Id.Split('.')[0]);
             returnval = _mseLevel;
         }
         _mseLastSpectrumLevel = returnval;
     }
     else
     {
         returnval = _mseLastSpectrumLevel; // we were just asked about this spectrum, no update this time
     }
     _mseLastSpectrum = dataSpectrum;
     return returnval;
 }
Exemple #23
0
 private static double SumIntensities(MsDataSpectrum[] spectra, double mz, int[] indices)
 {
     double intensity = 0;
     for (int i = 0; i < indices.Length; i++)
     {
         var scan = spectra[i];
         int indexMz;
         // Sometimes spectra have multiple intensities for a given m/z.  Sum all intensities for that m/z
         for (indexMz = indices[i]; indexMz < scan.Mzs.Length && scan.Mzs[indexMz] == mz; indexMz++)
         {
             intensity += scan.Intensities[indexMz];
         }
         indices[i] = indexMz;
     }
     return intensity;
 }
 public int NextIndex(int proposed)
 {
     if (_lookAheadIndex <= proposed)
     {
         _lookAheadIndex = proposed + 1;
         _lookAheadDataSpectrum = null;
     }
     return _lookAheadIndex;
 }
Exemple #25
0
        private void SetSpectraUI(MsDataSpectrum[] spectra)
        {
            _msDataFileScanHelper.MsDataSpectra = spectra;
            _heatMapData = null;
            if (_msDataFileScanHelper.MsDataSpectra == null)
                return;

            // Find max values.
            _maxMz = 0;
            _maxIntensity = 0;
            GetMaxMzIntensity(out _maxMz, out _maxIntensity);
            _maxDriftTime = 0;
            foreach (var spectrum in spectra)
                _maxDriftTime = Math.Max(_maxDriftTime, spectrum.DriftTimeMsec ?? 0);

            if (_zoomXAxis)
            {
                _zoomXAxis = false;
                ZoomXAxis();
            }
            if (_zoomYAxis)
            {
                _zoomYAxis = false;
                ZoomYAxis();
            }
            CreateGraph();
            UpdateUI();
        }
 private void SetScans(MsDataSpectrum[] scans)
 {
     lock (this)
     {
         _msDataFileScanHelper.MsDataSpectra = scans;
         Monitor.PulseAll(this);
     }
 }