Example #1
0
        public void GetMassSpectrumWithSummingTest1()
        {
            var run = new UIMFRun(FileRefs.RawDataMSFiles.UIMFStdFile3);

            var frame = new ScanSet(163, 162, 164);
            var scan  = new IMSScanSet(121);

            var xydata = run.GetMassSpectrum(frame, scan, 0, 50000);

            var testMZ = 627.2655682;
            var maxIntensityForTestMZ = 0;


            for (var i = 0; i < xydata.Xvalues.Length; i++)
            {
                if (xydata.Xvalues[i] > (testMZ - 0.1) && xydata.Xvalues[i] < (testMZ + 0.1))
                {
                    if (xydata.Yvalues[i] > maxIntensityForTestMZ)
                    {
                        maxIntensityForTestMZ = (int)xydata.Yvalues[i];
                    }
                }
            }

            Assert.AreEqual(126568, maxIntensityForTestMZ);
        }
        public override void InitializeRunRelatedTasks()
        {
            if (Run != null)
            {
                MSGenerator = MSGeneratorFactory.CreateMSGenerator(Run.MSFileType);
                int minLCScan;
                int maxLCScan;

                if (this._workflowParameters.LCScanMax == -1 || this._workflowParameters.LCScanMin == -1)
                {
                    if (Run is UIMFRun)
                    {
                        minLCScan = ((UIMFRun)Run).MinLCScan;
                        maxLCScan = ((UIMFRun)Run).MaxLCScan;
                    }
                    else
                    {
                        minLCScan = Run.MinLCScan;
                        maxLCScan = Run.MaxLCScan;
                    }
                }
                else
                {
                    minLCScan = this._workflowParameters.LCScanMin;
                    maxLCScan = this._workflowParameters.LCScanMax;
                }

                if (Run.MSFileType == DeconTools.Backend.Globals.MSFileType.PNNL_UIMF)
                {
                    var uimfRun = Run as UIMFRun;

                    uimfRun.ScanSetCollection.Create(uimfRun, minLCScan, maxLCScan,
                                                     _workflowParameters.Num_LC_TimePointsSummed, 1,
                                                     _workflowParameters.ProcessMSMS);


                    bool sumAllIMSScans = (_workflowParameters.NumIMSScansSummed == -1 ||
                                           _workflowParameters.NumIMSScansSummed > uimfRun.MaxLCScan);

                    if (sumAllIMSScans)
                    {
                        int primaryIMSScan = Run.MinLCScan;

                        uimfRun.IMSScanSetCollection.ScanSetList.Clear();
                        var imsScanset = new IMSScanSet(primaryIMSScan, uimfRun.MinIMSScan, uimfRun.MaxIMSScan);
                        uimfRun.IMSScanSetCollection.ScanSetList.Add(imsScanset);
                    }
                    else
                    {
                        uimfRun.IMSScanSetCollection.Create(Run, uimfRun.MinIMSScan, uimfRun.MaxIMSScan,
                                                            _workflowParameters.NumIMSScansSummed, 1);
                    }
                }
                else
                {
                    Run.ScanSetCollection.Create(Run, minLCScan, maxLCScan,
                                                 this._workflowParameters.Num_LC_TimePointsSummed, 1, this._workflowParameters.ProcessMSMS);
                }
            }
        }
Example #3
0
        protected override void CreateTargetMassSpectra()
        {
            var uimfRun = (UIMFRun)Run;

            uimfRun.ScanSetCollection    = new ScanSetCollection();
            uimfRun.IMSScanSetCollection = new IMSScanSetCollection();


            int numFramesSummed;

            if (NewDeconToolsParameters.MSGeneratorParameters.SumSpectraAcrossLC)
            {
                numFramesSummed = NewDeconToolsParameters.MSGeneratorParameters.NumLCScansToSum;
            }
            else
            {
                numFramesSummed = 1;
            }

            if (NewDeconToolsParameters.MSGeneratorParameters.UseLCScanRange)   //Defines whether or not to use all LC time points, or a restricted range
            {
                uimfRun.ScanSetCollection.Create(uimfRun, NewDeconToolsParameters.MSGeneratorParameters.MinLCScan,
                                                 NewDeconToolsParameters.MSGeneratorParameters.MaxLCScan, numFramesSummed, 1, NewDeconToolsParameters.ScanBasedWorkflowParameters.ProcessMS2);
            }
            else
            {
                uimfRun.ScanSetCollection.Create(uimfRun, numFramesSummed, 1);
            }



            var sumAllIMSScansInAFrame = (NewDeconToolsParameters.MSGeneratorParameters.SumAllSpectra);

            if (sumAllIMSScansInAFrame)
            {
                var centerScan = (uimfRun.MinIMSScan + uimfRun.MaxIMSScan + 1) / 2;

                uimfRun.IMSScanSetCollection.ScanSetList.Clear();
                var scanset = new IMSScanSet(centerScan, uimfRun.MinIMSScan, uimfRun.MaxIMSScan);
                uimfRun.IMSScanSetCollection.ScanSetList.Add(scanset);
            }
            else
            {
                var sumAcrossIMSScans = NewDeconToolsParameters.MSGeneratorParameters.SumSpectraAcrossIms;

                int numIMSScanToSum;
                if (sumAcrossIMSScans)
                {
                    numIMSScanToSum = NewDeconToolsParameters.MSGeneratorParameters.NumImsScansToSum;
                }
                else
                {
                    numIMSScanToSum = 1;
                }

                uimfRun.IMSScanSetCollection.Create(Run, uimfRun.MinIMSScan, uimfRun.MaxIMSScan, numIMSScanToSum, 1);
            }
        }
Example #4
0
        public void InitializeRunRelatedTasks()
        {
            if (Run != null)
            {
                MSGenerator = MSGeneratorFactory.CreateMSGenerator(Run.MSFileType);
                int minLCScan;
                int maxLCScan;

                if (WorkflowParameters.LCScanMax == -1 || WorkflowParameters.LCScanMin == -1)
                {
                    if (Run is UIMFRun thisUimfRun)
                    {
                        minLCScan = thisUimfRun.MinLCScan;
                        maxLCScan = thisUimfRun.MaxLCScan;
                    }
                    else
                    {
                        minLCScan = Run.MinLCScan;
                        maxLCScan = Run.MaxLCScan;
                    }
                }
                else
                {
                    minLCScan = WorkflowParameters.LCScanMin;
                    maxLCScan = WorkflowParameters.LCScanMax;
                }

                if (Run.MSFileType == Globals.MSFileType.PNNL_UIMF && Run is UIMFRun uimfRun)
                {
                    uimfRun.ScanSetCollection.Create(uimfRun, minLCScan, maxLCScan,
                                                     WorkflowParameters.Num_LC_TimePointsSummed, 1,
                                                     WorkflowParameters.ProcessMSMS);

                    var sumAllIMSScans = WorkflowParameters.NumIMSScansSummed == -1 ||
                                         WorkflowParameters.NumIMSScansSummed > uimfRun.MaxLCScan;

                    if (sumAllIMSScans)
                    {
                        var primaryIMSScan = Run.MinLCScan;

                        uimfRun.IMSScanSetCollection.ScanSetList.Clear();
                        var imsScanSet = new IMSScanSet(primaryIMSScan, uimfRun.MinIMSScan, uimfRun.MaxIMSScan);
                        uimfRun.IMSScanSetCollection.ScanSetList.Add(imsScanSet);
                    }
                    else
                    {
                        uimfRun.IMSScanSetCollection.Create(Run, uimfRun.MinIMSScan, uimfRun.MaxIMSScan,
                                                            WorkflowParameters.NumIMSScansSummed, 1);
                    }
                }
                else
                {
                    Run.ScanSetCollection.Create(Run, minLCScan, maxLCScan,
                                                 WorkflowParameters.Num_LC_TimePointsSummed, 1, WorkflowParameters.ProcessMSMS);
                }
            }
        }
        public ScanBasedProgressInfo(Run run, ScanSet scanSet, IMSScanSet imsScanSet = null)
        {
            CurrentRun     = run;
            CurrentScanSet = scanSet;

            if (CurrentRun is UIMFRun uimfRun)
            {
                if (imsScanSet == null)
                {
                    throw new NullReferenceException("ScanBasedProgressInfo error. You need to provide a valid IMSScanSet");
                }
                uimfRun.CurrentIMSScanSet = imsScanSet;
            }
        }
        public ScanBasedProgressInfo(Run currentRun, ScanSet scanSet, IMSScanSet imsScanSet = null)
        {
            this.currentRun     = currentRun;
            this.currentScanSet = scanSet;

            if (currentRun is UIMFRun)
            {
                if (imsScanSet == null)
                {
                    throw new NullReferenceException("ScanBasedProgressInfo error. You need to provide a valid IMSScanSet");
                }
                ((UIMFRun)currentRun).CurrentIMSScanSet = imsScanSet;
            }
        }
        protected override void IterateOverScans()
        {
            const int CONSOLE_INTERVAL_SECONDS = 15;

            const bool SKIP_DECONVOLUTION = false;

            var uimfRun = (UIMFRun)Run;

            var startTime      = DateTime.UtcNow;
            var dtLastProgress = DateTime.UtcNow.Subtract(new TimeSpan(1, 0, 0));

            var frameCountProcessed = 0;
            var maxRuntimeHours     = NewDeconToolsParameters.MiscMSProcessingParameters.MaxHoursPerDataset;

            // uimfRun.IMSScanSetCollection.ScanSetList =uimfRun.IMSScanSetCollection.ScanSetList.Where(p => p.PrimaryScanNumber == 153).ToList();

            // Iterate over unsummed data and fix saturated isotopic profiles. Unsummed will be used during a second iteration (over summed data)
            foreach (var lcScanSet in uimfRun.ScanSetCollection.ScanSetList)
            {
                uimfRun.ResultCollection.MSPeakResultList.Clear();
                _unsummedMSFeatures.Clear();

                var unsummedFrameSet = new ScanSet(lcScanSet.PrimaryScanNumber);

                // Get saturated MSFeatures for unsummed data
                uimfRun.CurrentScanSet = unsummedFrameSet;

                var forceProgressMessage  = true;
                var imsScanCountProcessed = 0;

                var maxMinutesPerFrame = NewDeconToolsParameters.MiscMSProcessingParameters.MaxMinutesPerFrame;
                if (uimfRun.GetNumFrames() <= 10)
                {
                    // Disable the per-frame timeout if we have 10 or fewer frames
                    maxMinutesPerFrame = int.MaxValue;
                }
                var frameStartTime = DateTime.UtcNow;
                var timeoutReached = false;

                foreach (var scanset in uimfRun.IMSScanSetCollection.ScanSetList)
                {
                    if (DateTime.UtcNow.Subtract(dtLastProgress).TotalSeconds >= CONSOLE_INTERVAL_SECONDS || forceProgressMessage)
                    {
                        dtLastProgress       = DateTime.UtcNow;
                        forceProgressMessage = false;
                        Console.WriteLine("Processing frame " + lcScanSet.PrimaryScanNumber + ", scan " + scanset.PrimaryScanNumber + " (Unsummed)");
                    }

                    if (DateTime.UtcNow.Subtract(frameStartTime).TotalMinutes >= maxMinutesPerFrame)
                    {
                        Console.WriteLine(
                            "Aborted processing of frame {0} because {1} minutes have elapsed (processing unsummed features); IMSScanCount processed = {2}",
                            lcScanSet.PrimaryScanNumber,
                            (int)DateTime.UtcNow.Subtract(frameStartTime).TotalMinutes,
                            imsScanCountProcessed);

                        timeoutReached = true;

                        break;
                    }

                    uimfRun.ResultCollection.IsosResultBin.Clear();  //clear any previous MSFeatures

                    var unsummedIMSScanset = new IMSScanSet(scanset.PrimaryScanNumber);
                    uimfRun.CurrentIMSScanSet = unsummedIMSScanset;

                    _msGenerator.Execute(Run.ResultCollection);

                    _zeroFiller.Execute(Run.ResultCollection);

                    // For debugging....
                    // if (scanset.PrimaryScanNumber == 123)
                    // {
                    //    Console.WriteLine(scanset + "\t being processed!");
                    // }

                    _peakDetector.Execute(Run.ResultCollection);

                    imsScanCountProcessed++;

                    if (SKIP_DECONVOLUTION)
                    {
                        continue;
                    }

                    // Deconvolute Unsummed MSFeatures
                    // This is a preliminary step for Saturation Detection

//#if Disable_DeconToolsV2
//                        throw new NotImplementedException("Cannot use class SaturationIMSScanBasedWorkflow since support for C++ based DeconToolsV2 is disabled");
//#else
                    _deconvolutor.Deconvolute(uimfRun.ResultCollection); //adds to IsosResultBin
//#endif

                    // Note: the deconvolutor automatically increases the MSFeatureCounter.
                    // Here, we don't want this, since this data is used only for saturation correction,
                    // not for generating the official MSFeatures list. So we need to
                    // correct the MSFeatureCounter value.
                    Run.ResultCollection.MSFeatureCounter = Run.ResultCollection.MSFeatureCounter -
                                                            Run.ResultCollection.IsosResultBin.Count;

                    _unsummedMSFeatures.AddRange(Run.ResultCollection.IsosResultBin);

                    // Iterate over unsummed MSFeatures and check for saturation
                    foreach (var isosResult in uimfRun.ResultCollection.IsosResultBin)
                    {
                        var msFeatureXYData = Run.XYData.TrimData(isosResult.IsotopicProfile.MonoPeakMZ - 10,
                                                                  isosResult.IsotopicProfile.MonoPeakMZ + 10);

                        var tempMZ      = isosResult.IsotopicProfile.MonoPeakMZ;
                        var currentScan = scanset.PrimaryScanNumber;

                        var isPossiblySaturated = isosResult.IntensityAggregate >
                                                  NewDeconToolsParameters.MiscMSProcessingParameters.SaturationThreshold;


                        // For debugging...
                        // UIMFIsosResult tempIsosResult = (UIMFIsosResult) isosResult;

                        // if (tempIsosResult.IMSScanSet.PrimaryScanNumber == 123)
                        // {
                        //    Console.WriteLine(tempIsosResult + "\t being processed!");
                        // }

                        if (isPossiblySaturated)
                        {
                            RebuildSaturatedIsotopicProfile(msFeatureXYData, isosResult, uimfRun.PeakList, out var theorIso);
                            AdjustSaturatedIsotopicProfile(isosResult.IsotopicProfile, theorIso, AdjustMonoIsotopicMasses, true);
                        }
                    }
                }


                // DisplayMSFeatures(_unsummedMSFeatures);

                // Now sum across IMSScans, deconvolute and adjust using saturation detection
                forceProgressMessage  = true;
                imsScanCountProcessed = 0;

                // Compute a buffer using .MaxMinutesPerFrame times 20%
                double maxFrameMinutesAddon = 0;
                var    bufferMinutes        = maxMinutesPerFrame * 0.2;
                if (bufferMinutes < 1)
                {
                    bufferMinutes = 1;
                }

                if (timeoutReached ||
                    DateTime.UtcNow.Subtract(frameStartTime).TotalMinutes + bufferMinutes >= maxMinutesPerFrame)
                {
                    // Maximum time per frame has been reached (or has almost been reached)
                    // Allow the next step to run for an additional bufferMinutes
                    maxFrameMinutesAddon = bufferMinutes;
                }

                foreach (var scanSet in uimfRun.IMSScanSetCollection.ScanSetList)
                {
                    var scanset = (IMSScanSet)scanSet;
                    if (DateTime.UtcNow.Subtract(dtLastProgress).TotalSeconds >= CONSOLE_INTERVAL_SECONDS || forceProgressMessage)
                    {
                        dtLastProgress       = DateTime.UtcNow;
                        forceProgressMessage = false;
                        Console.WriteLine("Processing frame " + lcScanSet.PrimaryScanNumber + ", scan " + scanset.PrimaryScanNumber + " (Summed)");
                    }

                    if (DateTime.UtcNow.Subtract(frameStartTime).TotalMinutes >= maxMinutesPerFrame + maxFrameMinutesAddon)
                    {
                        Console.WriteLine(
                            "Aborted processing of frame {0} because {1} minutes have elapsed (processing summed features); IMSScanCount processed = {2}",
                            lcScanSet.PrimaryScanNumber,
                            (int)DateTime.UtcNow.Subtract(frameStartTime).TotalMinutes,
                            imsScanCountProcessed);

                        break;
                    }

                    uimfRun.ResultCollection.IsosResultBin.Clear();  //clear any previous MSFeatures

                    // Get the summed isotopic profile
                    uimfRun.CurrentScanSet    = lcScanSet;
                    uimfRun.CurrentIMSScanSet = scanset;

                    ExecuteTask(MSGenerator);

                    if (NewDeconToolsParameters.MiscMSProcessingParameters.UseZeroFilling)
                    {
                        ExecuteTask(ZeroFiller);
                    }

                    if (NewDeconToolsParameters.MiscMSProcessingParameters.UseSmoothing)
                    {
                        ExecuteTask(Smoother);
                    }

                    ExecuteTask(PeakDetector);

                    imsScanCountProcessed++;

                    if (!SKIP_DECONVOLUTION)
                    {
                        ExecuteTask(Deconvolutor);


                        foreach (var isosResult in Run.ResultCollection.IsosResultBin)
                        {
                            var isPossiblySaturated = isosResult.IntensityAggregate >
                                                      NewDeconToolsParameters.MiscMSProcessingParameters.SaturationThreshold;



                            if (isPossiblySaturated)
                            {
                                var msFeatureXYData = Run.XYData.TrimData(isosResult.IsotopicProfile.MonoPeakMZ - 10,
                                                                          isosResult.IsotopicProfile.MonoPeakMZ + 10);


                                RebuildSaturatedIsotopicProfile(msFeatureXYData, isosResult, Run.PeakList, out var theorIso);
                                AdjustSaturatedIsotopicProfile(isosResult.IsotopicProfile, theorIso, AdjustMonoIsotopicMasses, false);

                                var currentScan = scanset.PrimaryScanNumber;
                                var currentMZ   = isosResult.IsotopicProfile.MonoPeakMZ;

                                UpdateReportedSummedPeakIntensities(isosResult, lcScanSet, scanset);
                            }
                            else
                            {
                            }

                            if (isosResult.IsotopicProfile.IsSaturated)
                            {
                                GetRebuiltFitScore(isosResult);
                            }
                        }
                    }


                    // Need to remove any duplicate MSFeatures (this occurs when incorrectly deisotoped profiles are built).
                    // Will do this by making the MSFeatureID the same. Then the Exporter will ensure that only one MSFeature per MSFeatureID
                    // is exported. This isn't ideal. Better to remove the features but this proves to be quite hard to do without large performance hits.
                    foreach (var isosResult in Run.ResultCollection.IsosResultBin)
                    {
                        double ppmToleranceForDuplicate = 20;
                        var    massTolForDuplicate      = ppmToleranceForDuplicate *
                                                          isosResult.IsotopicProfile.MonoIsotopicMass / 1e6;


                        var isosResultLocal      = isosResult;
                        var duplicateIsosResults = (from n in Run.ResultCollection.IsosResultBin
                                                    where
                                                    Math.Abs(n.IsotopicProfile.MonoIsotopicMass -
                                                             isosResultLocal.IsotopicProfile.MonoIsotopicMass) <
                                                    massTolForDuplicate && n.IsotopicProfile.ChargeState == isosResultLocal.IsotopicProfile.ChargeState
                                                    select n);

                        var minMSFeatureID = int.MaxValue;
                        foreach (var dup in duplicateIsosResults)
                        {
                            if (dup.MSFeatureID < minMSFeatureID)
                            {
                                minMSFeatureID = dup.MSFeatureID;
                            }
                            else
                            {
                                //here we have found a duplicate
                                dup.MSFeatureID = minMSFeatureID;

                                //because there are duplicates, we need to maintain the MSFeatureCounter so it doesn't skip values, as will
                                //happen when there are duplicates
                                //Run.ResultCollection.MSFeatureCounter--;
                            }
                        }
                    }

                    ExecuteTask(ResultValidator);

                    ExecuteTask(ScanResultUpdater);

                    if (NewDeconToolsParameters.ScanBasedWorkflowParameters.IsRefittingPerformed)
                    {
                        ExecuteTask(FitScoreCalculator);
                    }

                    // Allows derived classes to execute additional tasks
                    ExecuteOtherTasksHook();

                    if (ExportData)
                    {
                        // The following exporting tasks should be last
                        if (NewDeconToolsParameters.ScanBasedWorkflowParameters.ExportPeakData)
                        {
                            ExecuteTask(PeakToMSFeatureAssociator);
                            ExecuteTask(PeakListExporter);
                        }

                        ExecuteTask(IsosResultExporter);

                        ExecuteTask(ScanResultExporter);
                    }

                    ReportProgress();
                }

                frameCountProcessed++;

                if (DateTime.UtcNow.Subtract(startTime).TotalHours >= maxRuntimeHours)
                {
                    Console.WriteLine(
                        "Aborted processing because {0} hours have elapsed; Frames processed = {1}",
                        (int)DateTime.UtcNow.Subtract(startTime).TotalHours,
                        frameCountProcessed);

                    break;
                }
            }
        }
        public void GetUnsummedIntensitiesAndDetectSaturation(Run run, IEnumerable <IsosResult> resultList)
        {
            Check.Require(run != null, "SaturationDetector failed. Run is null");
            if (run == null)
            {
                return;
            }

            if (_msGenerator == null)
            {
                _msGenerator = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
            }

            if (run is UIMFRun uimfRun)
            {
                if (uimfRun.CurrentScanSet == null)
                {
                    throw new NullReferenceException("CurrentScanSet is null. You need to set it.");
                }
                if (uimfRun.CurrentIMSScanSet == null)
                {
                    throw new NullReferenceException("CurrentIMSScanSet is null. You need to set it.");
                }

                //this creates a FrameSet containing only the primary frame.  Therefore no summing will occur
                var lcScanSet = new ScanSet(uimfRun.CurrentScanSet.PrimaryScanNumber);

                //this creates a ScanSet containing only the primary scan.  Therefore no summing will occur
                var imsScanSet = new IMSScanSet(uimfRun.CurrentIMSScanSet.PrimaryScanNumber);

                //get the mass spectrum +/- 5 da from the range of the isotopicProfile

                uimfRun.CurrentScanSet    = lcScanSet;
                uimfRun.CurrentIMSScanSet = imsScanSet;
                _msGenerator.Execute(run.ResultCollection);
            }
            else
            {
                if (run.CurrentScanSet == null)
                {
                    throw new NullReferenceException("CurrentScanSet is null. You need to set it.");
                }

                //this creates a ScanSet containing only the primary scan.  Therefore no summing will occur
                var scanSet = new ScanSet(run.CurrentScanSet.PrimaryScanNumber);

                run.CurrentScanSet = scanSet;

                _msGenerator.Execute(run.ResultCollection);
            }

            foreach (var result in resultList)
            {
                var indexOfObsMostAbundant = result.IsotopicProfile.GetIndexOfMostIntensePeak();

                var mzOfMostAbundant = result.IsotopicProfile.Peaklist[indexOfObsMostAbundant].XValue;

                var indexOfUnsummedMostAbundantMZ = run.XYData.GetClosestXVal(mzOfMostAbundant);
                if (indexOfUnsummedMostAbundantMZ >= 0)
                {
                    result.IsotopicProfile.OriginalIntensity = run.XYData.Yvalues[indexOfUnsummedMostAbundantMZ];
                    result.IsotopicProfile.IsSaturated       = (result.IsotopicProfile.OriginalIntensity >=
                                                                SaturationThreshold);

                    if (result.IsotopicProfile.IsSaturated)
                    {
                        //problem is that with these saturated profiles, they are often truncated because another
                        //isotopic profile was falsely assigned to the back end of it. So we need to find more peaks that should
                        //belong to the saturated profile.
                        var theorTarget = new PeptideTarget
                        {
                            ChargeState      = (short)result.IsotopicProfile.ChargeState,
                            MonoIsotopicMass = result.IsotopicProfile.MonoIsotopicMass
                        };

                        theorTarget.MZ = (theorTarget.MonoIsotopicMass / theorTarget.ChargeState) + Globals.PROTON_MASS;

                        var averagineFormula = _tomIsotopicPatternGenerator.GetClosestAvnFormula(result.IsotopicProfile.MonoIsotopicMass, false);
                        theorTarget.IsotopicProfile  = _tomIsotopicPatternGenerator.GetIsotopePattern(averagineFormula, _tomIsotopicPatternGenerator.aafIsos);
                        theorTarget.EmpiricalFormula = averagineFormula;
                        theorTarget.CalculateMassesForIsotopicProfile(result.IsotopicProfile.ChargeState);

                        AssignMissingPeaksToSaturatedProfile(run.PeakList, result.IsotopicProfile, theorTarget.IsotopicProfile);

                        //goal is to find the index of the isotopic profile peaks of a peak that is not saturated

                        var indexOfGoodUnsaturatedPeak = -1;

                        for (var i = indexOfObsMostAbundant + 1; i < result.IsotopicProfile.Peaklist.Count; i++)
                        {
                            var indexUnsummedData = run.XYData.GetClosestXVal(result.IsotopicProfile.Peaklist[i].XValue);

                            var unsummedIntensity = run.XYData.Yvalues[indexUnsummedData];

                            if (unsummedIntensity < _minRelIntTheorProfile * SaturationThreshold)
                            {
                                indexOfGoodUnsaturatedPeak = i;
                                break;
                            }
                        }

                        AdjustSaturatedIsotopicProfile(result.IsotopicProfile, theorTarget.IsotopicProfile,
                                                       indexOfGoodUnsaturatedPeak);
                    }
                }

                //double summedIntensity = 0;
                //foreach (MSPeak peak in result.IsotopicProfile.Peaklist)
                //{
                //    int indexOfMZ = result.Run.XYData.GetClosestXVal(peak.XValue);
                //    if (indexOfMZ >= 0)
                //    {
                //        summedIntensity += result.Run.XYData.Yvalues[indexOfMZ];
                //    }
                //}

                //result.IsotopicProfile.OriginalTotalIsotopicAbundance = summedIntensity;
            }
        }
Example #9
0
        public void BPISaturationCorrectedTest1()
        {
            var filename = @"D:\Data\UIMF\Sarc_P13_C10_1186_23Sep11_Cheetah_11-09-06.uimf";
            var run      = new RunFactory().CreateRun(filename);

            run.ScanSetCollection = new ScanSetCollection();
            //scanSetCollection.Create(run, 500, 550,1,1);

            var startFrame = 477;
            var stopFrame  = 477;

            //startFrame = run.MinLCScan;
            //stopFrame = run.MaxLCScan;


            run.ScanSetCollection.Create(run, startFrame, stopFrame, 1, 1);



            ((UIMFRun)run).IMSScanSetCollection = new IMSScanSetCollection();
            ((UIMFRun)run).IMSScanSetCollection.Create(run, 122, 122, 1, 1);

            var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);

            var peakDet = new DeconToolsPeakDetectorV2();

            peakDet.PeakToBackgroundRatio  = 2;
            peakDet.SignalToNoiseThreshold = 2;
            peakDet.IsDataThresholded      = true;


            var _zeroFiller = new DeconToolsZeroFiller();

            var _deconvolutor = new ThrashDeconvolutorV2();

            _deconvolutor.UseAutocorrelationChargeDetermination = true;
            _deconvolutor.Parameters.MaxFit = 0.8;


            var saturationWorkflow = new SaturationIMSScanBasedWorkflow(new DeconToolsParameters(), run);



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

            using (var writer = new StreamWriter(outputFile))
            {
                var uimfRun = (UIMFRun)run;


                var _unsummedMSFeatures = new List <IsosResult>();

                foreach (var lcScanSet in run.ScanSetCollection.ScanSetList)
                {
                    Console.WriteLine("Scanset= " + lcScanSet);


                    uimfRun.ResultCollection.MSPeakResultList.Clear();
                    _unsummedMSFeatures.Clear();


                    var unsummedFrameSet = new ScanSet(lcScanSet.PrimaryScanNumber);
                    //get saturated MSFeatures for unsummed data
                    uimfRun.CurrentScanSet = unsummedFrameSet;


                    var sb = new StringBuilder();

                    var errorInFrame = false;
                    var numIMSScans  = uimfRun.IMSScanSetCollection.ScanSetList.Count;
                    for (var imsScanNum = 0; imsScanNum < numIMSScans; imsScanNum++)
                    {
                        var imsScanSet = uimfRun.IMSScanSetCollection.ScanSetList[imsScanNum];
                        uimfRun.ResultCollection.IsosResultBin.Clear(); //clear any previous MSFeatures

                        var unsummedIMSScanset = new IMSScanSet(imsScanSet.PrimaryScanNumber);
                        uimfRun.CurrentIMSScanSet = unsummedIMSScanset;

                        try
                        {
                            msgen.Execute(run.ResultCollection);

                            _zeroFiller.Execute(run.ResultCollection);

                            peakDet.Execute(run.ResultCollection);

                            _deconvolutor.Deconvolute(uimfRun.ResultCollection); //adds to IsosResultBin
                        }
                        catch (Exception ex)
                        {
                            errorInFrame = true;
                        }

                        _unsummedMSFeatures.AddRange(run.ResultCollection.IsosResultBin);


                        var basePeakIntensity = 0;
                        //iterate over unsummed MSFeatures and check for saturation
                        foreach (var isosResult in uimfRun.ResultCollection.IsosResultBin)
                        {
                            var isPossiblySaturated = isosResult.IntensityAggregate > 1e7;

                            if (isPossiblySaturated)
                            {
                                var theorIso = new IsotopicProfile();

                                saturationWorkflow.RebuildSaturatedIsotopicProfile(run.XYData, isosResult, uimfRun.PeakList, out theorIso);
                                saturationWorkflow.AdjustSaturatedIsotopicProfile(isosResult.IsotopicProfile, theorIso, true, true);
                            }


                            TestUtilities.DisplayIsotopicProfileData(isosResult.IsotopicProfile);


                            var height = (int)isosResult.IsotopicProfile.getMostIntensePeak().Height;
                            if (height > basePeakIntensity)
                            {
                                basePeakIntensity = height;
                            }
                        }


                        sb.Append(basePeakIntensity);

                        var isNotLastIMSScan = imsScanNum != numIMSScans - 1;
                        if (isNotLastIMSScan)
                        {
                            sb.Append("\t");
                        }
                    }

                    if (errorInFrame)
                    {
                    }
                    else
                    {
                        writer.WriteLine(sb.ToString());
                    }
                }
            }
        }