Beispiel #1
0
        public void TransitionLibraryDIAPrecursorExclusionTest()
        {
            // Create a document with the necessary library spectrum
            LibraryManager        libraryManager;
            TestDocumentContainer docContainer;
            int         startRev;
            SrmDocument document = LibrarySettingsTest.CreateNISTLibraryDocument(
                ">peptide1\nLECTDTLPDILENR",
                true,
                TEXT_LIB_YEAST_NIST_PRECURSOR,
                out libraryManager,
                out docContainer,
                out startRev);

            // Open up the transition filter settings and add a new isolation window scheme
            List <IsolationWindow> isolationWindows = new List <IsolationWindow>();

            // Parent mass is 844
            isolationWindows.Add(new IsolationWindow(600, 700)); // simple windows
            isolationWindows.Add(new IsolationWindow(700, 800)); // simple windows
            isolationWindows.Add(new IsolationWindow(800, 900)); // simple windows

            var settings = document.Settings
                           .ChangeTransitionLibraries(library =>
                                                      library.ChangePick(TransitionLibraryPick.all).
                                                      ChangeIonCount(10))
                           .ChangeTransitionFilter(filter =>
                                                   filter.ChangePeptideIonTypes(new[] { IonType.y, IonType.b })
                                                   .ChangeFragmentRangeFirstName("ion 1")
                                                   .ChangeFragmentRangeLastName("last ion")
                                                   .ChangeExclusionUseDIAWindow(true))
                           .ChangeTransitionFullScan(fs =>
                                                     fs.ChangeAcquisitionMethod(FullScanAcquisitionMethod.DIA,
                                                                                new IsolationScheme("Test", isolationWindows)));
            var docLibUnfiltered = document.ChangeSettings(settings);

            Assert.AreEqual(10, docLibUnfiltered.PeptideTransitionCount);
            Assert.AreEqual(1, docLibUnfiltered.PeptideTransitions.Count(nodeTran =>
                                                                         nodeTran.Transition.Ordinal <4 || nodeTran.Transition.Ordinal> nodeTran.Transition.Group.Peptide.Sequence.Length - 4));

            // Using a precursor filter should have no impact now, since the filter is being ignored
            var settingsP = settings.ChangeTransitionFilter(filter =>
                                                            filter.ChangePrecursorMzWindow(TransitionFilter.MAX_EXCLUSION_WINDOW));
            var docIgnorePrecursorMzWindow = docLibUnfiltered.ChangeSettings(settingsP);

            Assert.AreSame(docLibUnfiltered.Children, docIgnorePrecursorMzWindow.Children);

            // Should contain ions within the precursor window
            const int countInWindow        = 2;
            const int countInOverlapWindow = 5;

            Assert.AreEqual(countInWindow, docLibUnfiltered.PeptideTransitions.Count(nodeTran =>
                                                                                     nodeTran.Mz > 800 && nodeTran.Mz < 900));
            Assert.AreEqual(countInOverlapWindow, docLibUnfiltered.PeptideTransitions.Count(nodeTran =>
                                                                                            nodeTran.Mz > 750 && nodeTran.Mz < 1250));

            // Switch to filtered picking
            settings = settings.ChangeTransitionLibraries(library => library.ChangePick(TransitionLibraryPick.filter));
            var docLibFiltered = docLibUnfiltered.ChangeSettings(settings);

            Assert.AreEqual(10, docLibFiltered.PeptideTransitionCount);

            // Should not contain any more ions in the specified DIA window
            Assert.AreEqual(0, docLibFiltered.PeptideTransitions.Count(nodeTran =>
                                                                       nodeTran.Mz > 800 && nodeTran.Mz < 900));

            // But should contain ions within the extended precursor window
            const int countInOverlapWindowNew = 4;

            Assert.AreEqual(countInOverlapWindowNew, docLibFiltered.PeptideTransitions.Count(nodeTran =>
                                                                                             nodeTran.Mz > 750 && nodeTran.Mz < 1250));
            // But other transitions remain unchanged
            Assert.AreEqual(docLibUnfiltered.PeptideTransitionCount - countInWindow,
                            docLibFiltered.PeptideTransitions.ToList().ConvertAll(nodeTran => nodeTran.Transition)
                            .Intersect(docLibUnfiltered.PeptideTransitions.ToList().ConvertAll(nodeTran => nodeTran.Transition)).Count());

            // Add more windows to the document
            isolationWindows.Add(new IsolationWindow(750, 850));  // overlapping windows
            isolationWindows.Add(new IsolationWindow(840, 950));  // overlapping windows
            isolationWindows.Add(new IsolationWindow(840, 1250)); // overlapping windows
            var settingsNew = settings.ChangeTransitionFullScan(fs =>
                                                                fs.ChangeAcquisitionMethod(FullScanAcquisitionMethod.DIA,
                                                                                           new IsolationScheme("Test", isolationWindows)));
            var docFilterAdditionalWindows = docLibFiltered.ChangeSettings(settingsNew);

            // Check that now no more transitions are between 750 and 1250
            Assert.AreEqual(10, docFilterAdditionalWindows.PeptideTransitionCount);
            Assert.AreEqual(0, docFilterAdditionalWindows.PeptideTransitions.Count(nodeTran =>
                                                                                   nodeTran.Mz > 750 && nodeTran.Mz < 1250));
            // But other transitions remain unchanged
            Assert.AreEqual(docLibUnfiltered.PeptideTransitionCount - countInOverlapWindow,
                            docFilterAdditionalWindows.PeptideTransitions.ToList().ConvertAll(nodeTran => nodeTran.Transition)
                            .Intersect(docLibUnfiltered.PeptideTransitions.ToList().ConvertAll(nodeTran => nodeTran.Transition)).Count());

            // Reset the settings, and make sure the transitions return to previous state
            var docReset = docFilterAdditionalWindows.ChangeSettings(settings);

            Assert.AreEqual(docLibFiltered, docReset);

            // The filter should be turned off again when setting ExclusionUseDIAWindow to false
            var settingsNoFilter = settings.ChangeTransitionFilter(filter =>
                                                                   filter.ChangeExclusionUseDIAWindow(false));
            var docNoFilterAgain = docLibFiltered.ChangeSettings(settingsNoFilter);

            Assert.AreEqual(10, docNoFilterAgain.PeptideTransitionCount);
            Assert.AreEqual(countInOverlapWindow, docNoFilterAgain.PeptideTransitions.Count(nodeTran =>
                                                                                            nodeTran.Mz > 750 && nodeTran.Mz < 1250));
        }
Beispiel #2
0
        public void TransitionLibrary07Test()
        {
            // Create a document with the necessary library spectrum
            LibraryManager        libraryManager;
            TestDocumentContainer docContainer;
            int         startRev;
            SrmDocument document = LibrarySettingsTest.CreateNISTLibraryDocument(
                ">peptide1\nLECTDTLPDILENR",
                true,
                TEXT_LIB_YEAST_NIST_PRECURSOR,
                out libraryManager,
                out docContainer,
                out startRev);

            // Open up the transition filter settings before testing the precursor m/z window
            var settings = document.Settings
                           .ChangeTransitionLibraries(library =>
                                                      library.ChangePick(TransitionLibraryPick.all).
                                                      ChangeIonCount(10))
                           .ChangeTransitionFilter(filter =>
                                                   filter.ChangePeptideIonTypes(new[] { IonType.y, IonType.b })
                                                   .ChangeFragmentRangeFirstName("ion 4")
                                                   .ChangeFragmentRangeLastName("last ion - 3"));
            var docLibUnfiltered = document.ChangeSettings(settings);

            Assert.AreEqual(10, docLibUnfiltered.PeptideTransitionCount);
            Assert.AreEqual(1, docLibUnfiltered.PeptideTransitions.Count(nodeTran =>
                                                                         nodeTran.Transition.Ordinal <4 || nodeTran.Transition.Ordinal> nodeTran.Transition.Group.Peptide.Sequence.Length - 4));

            // Using a precursor filter should have no impact now, since the filter is being ignored
            var settingsP = settings.ChangeTransitionFilter(filter =>
                                                            filter.ChangePrecursorMzWindow(TransitionFilter.MAX_EXCLUSION_WINDOW));
            var docIgnorePrecursorMzWindow = docLibUnfiltered.ChangeSettings(settingsP);

            Assert.AreSame(docLibUnfiltered.Children, docIgnorePrecursorMzWindow.Children);

            // Switch to filtered picking
            settings = settings.ChangeTransitionLibraries(library => library.ChangePick(TransitionLibraryPick.filter));
            var docLibFiltered = docLibUnfiltered.ChangeSettings(settings);

            Assert.AreEqual(10, docLibFiltered.PeptideTransitionCount);
            // Should have removed the ions outside the previously specified range
            Assert.IsFalse(docLibFiltered.PeptideTransitions.Contains(nodeTran =>
                                                                      nodeTran.Transition.Ordinal <4 || nodeTran.Transition.Ordinal> nodeTran.Transition.Group.Peptide.Sequence.Length - 4));
            // But should contain ions within the precursor window
            double       precursorMz   = docLibFiltered.PeptideTransitionGroups.ToArray()[0].PrecursorMz;
            const int    countInWindow = 2;
            const double maxDelta      = TransitionFilter.MAX_EXCLUSION_WINDOW / 2;

            Assert.AreEqual(countInWindow, docLibFiltered.PeptideTransitions.Count(nodeTran =>
                                                                                   Math.Abs(precursorMz - nodeTran.Mz) < maxDelta));

            // Set a precursor m/z window for real this time
            settingsP = settings.ChangeTransitionFilter(filter =>
                                                        filter.ChangePrecursorMzWindow(TransitionFilter.MAX_EXCLUSION_WINDOW));
            var docPrecursorMzWindow = docLibFiltered.ChangeSettings(settingsP);

            Assert.AreEqual(10, docPrecursorMzWindow.PeptideTransitionCount);
            // Make sure transitions in the window were removed
            Assert.IsFalse(docPrecursorMzWindow.PeptideTransitions.Contains(nodeTran =>
                                                                            Math.Abs(precursorMz - nodeTran.Mz) < maxDelta));
            // But other transitions remain unchanged
            Assert.AreEqual(docPrecursorMzWindow.PeptideTransitionCount - countInWindow,
                            docPrecursorMzWindow.PeptideTransitions.ToList().ConvertAll(nodeTran => nodeTran.Transition)
                            .Intersect(docLibFiltered.PeptideTransitions.ToList().ConvertAll(nodeTran => nodeTran.Transition)).Count());

            // Reset the settings, and make sure the transitions return to previous state
            var docReset = docPrecursorMzWindow.ChangeSettings(settings);

            Assert.AreEqual(docLibFiltered, docReset);

            // Restrict ion count chosen from the library
            settings = settings.ChangeTransitionLibraries(library => library.ChangeIonCount(3))
                       .ChangeTransitionFilter(filter => filter.ChangePeptideIonTypes(new[] { IonType.y }));
            var docThreeTran = docReset.ChangeSettings(settings);

            Assert.AreEqual(3, docThreeTran.PeptideTransitionCount);
            // Make sure ions below precursor m/z are present
            Assert.AreEqual(2, docThreeTran.PeptideTransitions.Count(nodeTran => nodeTran.Mz < precursorMz));

            // Change the filter and picking to library-plus-filter
            // with a more restricted filter.
            settings = settings
                       .ChangeTransitionLibraries(library =>
                                                  library.ChangePick(TransitionLibraryPick.all_plus))
                       .ChangeTransitionFilter(filter =>
                                               filter.ChangeFragmentRangeFirstName("m/z > precursor")
                                               .ChangeFragmentRangeLastName("3 ions"));
            var docLibPlus = docThreeTran.ChangeSettings(settings);

            Assert.AreEqual(5, docLibPlus.PeptideTransitionCount);
            // Make sure ions below precursor m/z are present
            Assert.AreEqual(3, docLibPlus.PeptideTransitions.Count(nodeTran => nodeTran.Mz > precursorMz));
        }