예제 #1
0
        protected override void InitializeSolver()
        {
            var maxTransInSpectrum = _spectrumProcessor.MaxTransitions(IsoWindowsPerScan);

            _deconvHandler = new MsxDeconvSolverHandler(NumDeconvRegions, NumScansBlock, maxTransInSpectrum);
            _solver        = new NonNegLsSolver(NumDeconvRegions, NumScansBlock, maxTransInSpectrum, true);
        }
예제 #2
0
        protected override void InitializeSolver()
        {
            int maxOverlapComponents = _isoMapper.MaxDeconvInIsoWindow();
            var maxTransInSpectrum   = _spectrumProcessor.MaxTransitions(maxOverlapComponents * IsoWindowsPerScan);

            _deconvHandler = new MsxDeconvSolverHandler(NumDeconvRegions, NumScansBlock, maxTransInSpectrum);
            _solver        = new NonNegLsSolver(NumDeconvRegions, NumScansBlock, maxTransInSpectrum, true);
        }
예제 #3
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;
        }
예제 #4
-1
 protected override void InitializeSolver()
 {
     var maxTransInSpectrum = _spectrumProcessor.MaxTransitions(IsoWindowsPerScan);
     _deconvHandler = new MsxDeconvSolverHandler(NumDeconvRegions, NumScansBlock, maxTransInSpectrum);
     _solver = new NonNegLsSolver(NumDeconvRegions, NumScansBlock, maxTransInSpectrum, true);
 }
예제 #5
-1
 protected override void InitializeSolver()
 {
     int maxOverlapComponents = _isoMapper.MaxDeconvInIsoWindow();
     var maxTransInSpectrum = _spectrumProcessor.MaxTransitions(maxOverlapComponents * IsoWindowsPerScan);
     _deconvHandler = new MsxDeconvSolverHandler(NumDeconvRegions, NumScansBlock, maxTransInSpectrum);
     _solver = new NonNegLsSolver(NumDeconvRegions, NumScansBlock, maxTransInSpectrum, true);
 }