예제 #1
0
        public void importIsosResultsAndFilterOnChargeStatesTest1()
        {
            IsosResultUtilities isosUtil = new IsosResultUtilities();
            isosUtil.LoadResults(xcaliburThrashIsos1, DeconTools.Backend.Globals.MSFileType.Finnigan);

            Assert.AreEqual(11610, isosUtil.Results.Count);

            List<IsosResult> chargeOneResultsOnly = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 1, IsosResultUtilities.enumLinqOperator.EqualTo);
            List<IsosResult> chargeTwoResultsOnly = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 2, IsosResultUtilities.enumLinqOperator.EqualTo);
            List<IsosResult> chargeThreeResultsOnly = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 3, IsosResultUtilities.enumLinqOperator.EqualTo);
            List<IsosResult> chargeFourResultsOnly = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 4, IsosResultUtilities.enumLinqOperator.EqualTo);
            List<IsosResult> chargeFiveResultsOnly = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 5, IsosResultUtilities.enumLinqOperator.EqualTo);
            List<IsosResult> chargeSixResultsOnly = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 6, IsosResultUtilities.enumLinqOperator.EqualTo);

            List<IsosResult> resultsWithChargeLessThan4 = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 4, IsosResultUtilities.enumLinqOperator.lessThan);
            List<IsosResult> resultsWithChargeMoreThan6 = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 6, IsosResultUtilities.enumLinqOperator.greaterThan);

            Assert.AreEqual(2323, chargeOneResultsOnly.Count);
            Assert.AreEqual(5244, chargeTwoResultsOnly.Count);
            Assert.AreEqual(2866, chargeThreeResultsOnly.Count);
            Assert.AreEqual(946, chargeFourResultsOnly.Count);
            Assert.AreEqual(153, chargeFiveResultsOnly.Count);
            Assert.AreEqual(56, chargeSixResultsOnly.Count);

            Assert.AreEqual(2323 + 5244 + 2866, resultsWithChargeLessThan4.Count);
            Assert.AreEqual(22, resultsWithChargeMoreThan6.Count);



        }
        public void importLargeIsosFileTest1()
        {
            IsosResultUtilities isosUtil = new IsosResultUtilities();

            isosUtil.LoadResults(largeIsosFile1, DeconTools.Backend.Globals.MSFileType.Finnigan);

            Assert.AreEqual(217847, isosUtil.Results.Count);

            int count = IsosResultUtilities.getCount(isosUtil.Results);

            Assert.AreEqual(200665, count);

            List <IsosResult> chargeOneResultsOnly   = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 1, IsosResultUtilities.enumLinqOperator.EqualTo);
            List <IsosResult> chargeTwoResultsOnly   = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 2, IsosResultUtilities.enumLinqOperator.EqualTo);
            List <IsosResult> chargeThreeResultsOnly = IsosResultUtilities.getIsosResultsByChargeState(isosUtil.Results, 3, IsosResultUtilities.enumLinqOperator.EqualTo);


            Assert.AreEqual(27541, chargeOneResultsOnly.Count);

            double avgScore = IsosResultUtilities.getAverageScore(chargeOneResultsOnly);
            double stdev    = IsosResultUtilities.getStdDevScore(chargeOneResultsOnly);

            Console.WriteLine(avgScore);
            Console.WriteLine(stdev);
        }
예제 #3
0
        public void loadUIMFIsosResults_loadOneFrameOnly_Test1()
        {
            IsosResultUtilities isosUtil = new IsosResultUtilities();
            isosUtil.LoadResults(uimfIsos1, DeconTools.Backend.Globals.MSFileType.PNNL_UIMF,500);

            Assert.AreEqual(1346, isosUtil.Results.Count);

            UIMFIsosResult uimfTestResult1 = (UIMFIsosResult)isosUtil.Results[3];

            Assert.AreEqual(1200, uimfTestResult1.FrameSet.PrimaryFrame);
            Assert.AreEqual(250, uimfTestResult1.ScanSet.PrimaryScanNumber);
            Assert.AreEqual(3, uimfTestResult1.IsotopicProfile.ChargeState);
            Assert.AreEqual(1288, uimfTestResult1.IsotopicProfile.GetAbundance());
            //Assert.AreEqual(432.92416, uimfTestResult1.IsotopicProfile.GetMZofMostAbundantPeak());
            Assert.AreEqual(0.1458, uimfTestResult1.IsotopicProfile.Score);
            //Assert.AreEqual(1296.54608, uimfTestResult1.IsotopicProfile.AverageMass);
            Assert.AreEqual(1295.75229, uimfTestResult1.IsotopicProfile.MonoIsotopicMass);
            Assert.AreEqual(0.0548, Math.Round(uimfTestResult1.IsotopicProfile.GetFWHM(), 4));
            Assert.AreEqual(92, uimfTestResult1.IsotopicProfile.GetSignalToNoise());



            //Assert.AreEqual(1200, uimfTestResult1.FrameSet.PrimaryFrame);

            //250	3	1288	432.92416	0.1458	1296.54608	1295.75229	1295.75229	0.0548	92


        }
예제 #4
0
        public void test2()
        {
            IsosResultComparer comparer = new IsosResultComparer();

            IsosResultUtilities isosUtil = new IsosResultUtilities();

            isosUtil.LoadResults(xcaliburThrashIsos1, DeconTools.Backend.Globals.MSFileType.Finnigan);

            IsosResultUtilities isosUtil2 = new IsosResultUtilities();

            isosUtil2.LoadResults(xcaliburThrashIsos1, DeconTools.Backend.Globals.MSFileType.Finnigan);


            List <IsosResult> resultList1 = isosUtil.Results.Where(p => p.ScanSet.PrimaryScanNumber == 6005).ToList();
            List <IsosResult> resultList2 = isosUtil2.Results.Where(p => p.ScanSet.PrimaryScanNumber == 6005).ToList();;

            Assert.AreEqual(86, resultList1.Count);
            Assert.AreEqual(86, resultList2.Count);

            resultList1.RemoveAt(30);
            resultList1.RemoveAt(30);
            resultList1.RemoveAt(30);

            resultList2.RemoveAt(0);
            resultList2.RemoveAt(0);
            resultList2.RemoveAt(0);
            resultList2.RemoveAt(0);
            Assert.AreEqual(86 - 4, resultList2.Count);
            Assert.AreEqual(86 - 3, resultList1.Count);

            List <IsosResult> intersectedList = comparer.GetIntersectionBetweenTwoIsosResultSets(resultList1, resultList2);

            Assert.AreEqual(86 - 7, intersectedList.Count);
        }
        public void test1_summing()
        {
            Project.Reset();
            Project project = Project.getInstance();

            UIMFRun run = new UIMFRun(uimfFilepath, 1201, 1201);

            project.RunCollection.Add(run);

            int numFramesSummed = 3;
            int numScansSummed  = 3;

            ScanSetCollectionCreator sscc = new ScanSetCollectionCreator(run, 250, 270, numScansSummed, 1);

            sscc.Create();

            FrameSetCollectionCreator fscc = new FrameSetCollectionCreator(run, run.MinFrame, run.MaxFrame, numFramesSummed, 1);

            fscc.Create();

            Task msGen = new UIMF_MSGenerator(200, 2000);

            DeconToolsV2.Peaks.clsPeakProcessorParameters detectorParams = new DeconToolsV2.Peaks.clsPeakProcessorParameters();
            detectorParams.PeakBackgroundRatio    = 3;
            detectorParams.PeakFitType            = DeconToolsV2.Peaks.PEAK_FIT_TYPE.QUADRATIC;
            detectorParams.SignalToNoiseThreshold = 3;
            Task peakDetector = new DeconToolsPeakDetector(detectorParams);

            Task decon = new HornDeconvolutor();

            Task scanResultsUpdater = new ScanResultUpdater();

            Task originalIntensitiesExtractor = new OriginalIntensitiesExtractor();


            project.TaskCollection.TaskList.Add(msGen);
            project.TaskCollection.TaskList.Add(peakDetector);
            project.TaskCollection.TaskList.Add(decon);
            project.TaskCollection.TaskList.Add(scanResultsUpdater);
            project.TaskCollection.TaskList.Add(originalIntensitiesExtractor);

            TaskController controller = new UIMF_TaskController(project.TaskCollection);

            controller.Execute(project.RunCollection);

            ResultCollection rc = project.RunCollection[0].ResultCollection;

            Assert.AreEqual(180, rc.ResultList.Count);

            StringBuilder sb = new StringBuilder();

            IsosResultUtilities.DisplayResults(sb, rc.ResultList);
            Console.Write(sb.ToString());
        }
        public void getAverageScoreTest1()
        {
            TestUtilities     testUtils     = new TestUtilities();
            List <IsosResult> thrashResults = testUtils.CreateThrashIsosResults1();

            outputFitValuesToConsole(thrashResults);

            double avgFit = IsosResultUtilities.getAverageScore(thrashResults);

            Assert.AreEqual(0.0482473459193904, (decimal)avgFit);
        }
        public void loadIMFResultsAndThenExport()
        {
            IsosResultUtilities iru     = new IsosResultUtilities();
            List <IsosResult>   results = iru.getIMFResults(imfIsosFolder, 500, 600);

            UIMFIsosExporter exporter = new UIMFIsosExporter(Path.Combine(imfIsosFolder, "mergedIsosResults.csv"));

            ResultCollection rc = new ResultCollection(new IMFRun());

            rc.ResultList = results;
            exporter.Export(rc);
        }
        public void getSpecificChargeStateResultsOnlyTest1()
        {
            TestUtilities     testUtils     = new TestUtilities();
            List <IsosResult> thrashResults = testUtils.CreateThrashIsosResults1();

            List <IsosResult> chargeTwoResultsOnly = IsosResultUtilities.getIsosResultsByChargeState(thrashResults, 2, IsosResultUtilities.enumLinqOperator.EqualTo);

            foreach (IsosResult result in chargeTwoResultsOnly)
            {
                Assert.AreEqual(2, result.IsotopicProfile.ChargeState);
            }
            Assert.AreEqual(136, chargeTwoResultsOnly.Count);



            double avgFit = IsosResultUtilities.getAverageScore(chargeTwoResultsOnly);

            Assert.AreEqual(0.0490575547734101m, (decimal)avgFit);
        }
예제 #9
0
        public void loadIMFIsosResultTest1()
        {
            IsosResultUtilities isosUtil = new IsosResultUtilities();
            isosUtil.LoadResults(imfIsos1, DeconTools.Backend.Globals.MSFileType.PNNL_IMS);

            Assert.AreEqual(43, isosUtil.Results.Count);

            IsosResult imfTestResult1 = isosUtil.Results[3];

            Assert.AreEqual(231, imfTestResult1.ScanSet.PrimaryScanNumber);
            Assert.AreEqual(2, imfTestResult1.IsotopicProfile.ChargeState);
            Assert.AreEqual(7768, imfTestResult1.IsotopicProfile.GetAbundance());
            //Assert.AreEqual(432.92416, uimfTestResult1.IsotopicProfile.GetMZofMostAbundantPeak());
            Assert.AreEqual(0.0098, imfTestResult1.IsotopicProfile.Score);
            //Assert.AreEqual(1142.4074, uimfTestResult1.IsotopicProfile.AverageMass);
            Assert.AreEqual(1141.7091, imfTestResult1.IsotopicProfile.MonoIsotopicMass);
            Assert.AreEqual(0.0633,Math.Round(imfTestResult1.IsotopicProfile.GetFWHM(),4));
            Assert.AreEqual(112.58, Math.Round(imfTestResult1.IsotopicProfile.GetSignalToNoise(),2));

            //231,2,7768,571.8613,0.0098,1142.4074,1141.7091,1141.7091,0.0633,112.58,7768,1640

        }
예제 #10
0
        public void compareThrashRapidTest1()
        {
            IsosResultComparer comparer = new IsosResultComparer();

            IsosResultUtilities isosUtil = new IsosResultUtilities();

            isosUtil.LoadResults(isosByThrash1, DeconTools.Backend.Globals.MSFileType.Finnigan);

            IsosResultUtilities isosUtil2 = new IsosResultUtilities();

            isosUtil2.LoadResults(isosByRapid1, DeconTools.Backend.Globals.MSFileType.Finnigan);


            List <IsosResult> rapidResults  = isosUtil2.Results;
            List <IsosResult> thrashResults = isosUtil.Results;

            Console.WriteLine("Thrash result count = " + thrashResults.Count);
            Console.WriteLine("RAPID result count = " + rapidResults.Count);



            List <IsosResult> intersectedResults = comparer.GetIntersectionBetweenTwoIsosResultSets(thrashResults, rapidResults);
            //List<IsosResult> intersectedResults2 = comparer.GetIntersectionTheManualWay(thrashResults, rapidResults);
            //List<IsosResult> intersectedResults3 = comparer.GetIntersectionTheManualWay(rapidResults, thrashResults);

            List <IsosResult> unmatchedResults1 = comparer.GetUniqueBetweenTwoIsosResultSets(rapidResults, thrashResults);
            List <IsosResult> unmatchedResults2 = comparer.GetUniqueBetweenTwoIsosResultSets(thrashResults, rapidResults);



            Console.WriteLine("Intersected result count = " + intersectedResults.Count);
            //Console.WriteLine("Manual Intersected result count = " + intersectedResults2.Count);
            //Console.WriteLine("Manual Intersected result count = " + intersectedResults3.Count);

            Console.WriteLine("unmatched result count = " + unmatchedResults1.Count);
            Console.WriteLine("unmatched result count2 = " + unmatchedResults2.Count);
        }
예제 #11
0
        public void compareRAWData_cacheONvs_cacheOffTest1()
        {
            IsosResultComparer comparer = new IsosResultComparer();

            IsosResultUtilities isosUtil = new IsosResultUtilities();

            isosUtil.LoadResults(rawIsosCacheOnCompleteFitOFF, DeconTools.Backend.Globals.MSFileType.Finnigan);

            IsosResultUtilities isosUtil2 = new IsosResultUtilities();

            isosUtil2.LoadResults(rawIsosCacheOFFCompleteFitOFF, DeconTools.Backend.Globals.MSFileType.Finnigan);


            List <IsosResult> cacheOnResults  = isosUtil.Results;
            List <IsosResult> cacheOffResults = isosUtil2.Results;

            Console.WriteLine("cache on count = " + cacheOnResults.Count);
            Console.WriteLine("cache off count = " + cacheOffResults.Count);



            List <IsosResult> intersectedResults = comparer.GetIntersectionBetweenTwoIsosResultSets(cacheOffResults, cacheOnResults);

            List <IsosResult> unmatchedResults1 = comparer.GetUniqueBetweenTwoIsosResultSets(cacheOnResults, cacheOffResults);
            List <IsosResult> unmatchedResults2 = comparer.GetUniqueBetweenTwoIsosResultSets(cacheOffResults, cacheOnResults);

            List <IsosResult> intersectedResults2 = comparer.GetIntersectionTheManualWay(cacheOnResults, cacheOffResults);

            //List<IsosResult> intersectedResults3 = comparer.GetIntersectionTheManualWay(rapidResults, thrashResults);

            Console.WriteLine("Intersected result count = " + intersectedResults.Count);
            Console.WriteLine("unmatched result count = " + unmatchedResults1.Count);
            Console.WriteLine("unmatched result count2 = " + unmatchedResults2.Count);
            Console.WriteLine("Manual Intersected result count = " + intersectedResults2.Count);
            //Console.WriteLine("Manual Intersected result count = " + intersectedResults3.Count);
        }
예제 #12
0
        public void Generate3dBpiFromIsosFile1()
        {
            var outputOrigIntensity = false;
            var outputToConsole     = true;

            var isosFile =
                @"D:\Data\UIMF\Sarc_P13_C10_1186_23Sep11_Cheetah_11-09-06_isos.csv";

            var outputFile = @"C:\Users\d3x720\Documents\PNNL\My_DataAnalysis\2013\Saturation_Correction\chromOuputSatCorrected.txt";

            var lcScanStart = 450;
            var lcScanStop  = 550;


            var isosResultUtilities = new IsosResultUtilities();
            var filteredIsos        = isosResultUtilities.getUIMFResults(isosFile, lcScanStart, lcScanStop);


            var outputIsosFilename = isosFile.Replace("_isos.csv", "_frame450-550_isos.csv");

            var indexFrameCol = 1;

            isosResultUtilities.FilterAndOutputIsos(isosFile, indexFrameCol, lcScanStart, lcScanStop, outputIsosFilename);


            var imsScanStart = 60;
            var imsScanStop  = 250;


            var startFrameIndex = 0;

            using (var writer = new StreamWriter(outputFile))
            {
                for (var scan = lcScanStart; scan <= lcScanStop; scan++)
                {
                    //Console.WriteLine("Frame = " + scan);

                    var lcScanResults = (from n in filteredIsos where n.ScanSet.PrimaryScanNumber == scan select n).ToList();

                    var sb = new StringBuilder();
                    for (var imsScan = imsScanStart; imsScan <= imsScanStop; imsScan++)
                    {
                        var imsScanResults =
                            (from n in lcScanResults
                             where ((UIMFIsosResult)n).IMSScanSet.PrimaryScanNumber == imsScan
                             orderby((UIMFIsosResult)n).IntensityAggregate descending
                             select n).ToList();

                        var basePeakIntensity = 0;
                        if (imsScanResults.Count == 0)
                        {
                        }
                        else
                        {
                            if (outputOrigIntensity)
                            {
                                basePeakIntensity = (int)imsScanResults.First().IsotopicProfile.getMostIntensePeak().Height;
                            }
                            else
                            {
                                basePeakIntensity = (int)imsScanResults.First().IntensityAggregate;
                            }
                        }

                        sb.Append(basePeakIntensity);

                        if (imsScan != imsScanStop)
                        {
                            sb.Append("\t");
                        }
                    }

                    writer.WriteLine(sb.ToString());
                    if (outputToConsole)
                    {
                        Console.WriteLine(sb.ToString());
                    }
                }
            }
        }