示例#1
0
 public PeakList()
 {
     ScanMode            = string.Empty;
     PrecursorPercentage = 0.0;
     Precursor           = new PrecursorPeak();
     CombinedCount       = 1;
 }
        protected virtual IEnumerable <string> DoProcess(string fileName, List <int> ignoreScans, int lastScan, bool bContinue)
        {
            var result = new List <string>();

            bool bReadAgain = false;

            using (var rawReader = RawFileFactory.GetRawFileReader(fileName))
            {
                try
                {
                    if (!bContinue)
                    {
                        DoInitialize(rawReader, fileName);
                    }

                    string experimental = rawReader.GetFileNameWithoutExtension(fileName);

                    SetMessage("Processing " + fileName + " ...");

                    int firstSpectrumNumber = rawReader.GetFirstSpectrumNumber();
                    int lastSpectrumNumber  = rawReader.GetLastSpectrumNumber();
                    //int firstSpectrumNumber = 79800;

                    SetRange(firstSpectrumNumber, lastSpectrumNumber);

                    lastScan = Math.Max(lastScan, firstSpectrumNumber);
                    for (int scan = lastScan; scan <= lastSpectrumNumber; scan++)
                    {
                        lastScan = scan;

                        if (Progress.IsCancellationPending())
                        {
                            throw new UserTerminatedException();
                        }

                        if (IsLoopStopped)
                        {
                            return(result);
                        }

                        if (ignoreScans.Contains(scan))
                        {
                            continue;
                        }

                        SetPosition(scan);

                        int msLevel = rawReader.GetMsLevel(scan);

                        if (!DoAcceptMsLevel(msLevel))
                        {
                            continue;
                        }

                        //Console.WriteLine("Reading scan {0}", scan);

                        PeakList <Peak> pkl;
                        try
                        {
                            PrecursorPeak precursor = null;
                            if (msLevel > 1)
                            {
                                precursor = new PrecursorPeak(rawReader.GetPrecursorPeak(scan));
                            }

                            pkl              = rawReader.GetPeakList(scan);
                            pkl.MsLevel      = msLevel;
                            pkl.Experimental = experimental;
                            pkl.ScanMode     = rawReader.GetScanMode(scan);
                            pkl.Precursor    = precursor;

                            if (msLevel > 1 && precursor.Charge == 0)
                            {
                                precursor.Charge = PrecursorUtils.GuessPrecursorCharge(pkl, pkl.PrecursorMZ);
                            }
                        }
                        catch
                        {
                            Console.WriteLine("Scan {0} ignored.", scan);
                            ignoreScans.Add(scan);
                            File.WriteAllLines(GetIgnoreScanFile(fileName), (from i in ignoreScans
                                                                             let s = i.ToString()
                                                                                     select s).ToArray());
                            bReadAgain = true;
                            break;
                        }

                        PeakList <Peak> pklProcessed;
                        if (msLevel > 1)
                        {
                            if (null == this.PeakListProcessor || (options.ExtractRawMS3 && pkl.MsLevel >= 3))
                            {
                                pklProcessed = pkl;
                            }
                            else
                            {
                                pklProcessed = this.PeakListProcessor.Process(pkl);
                            }
                        }
                        else
                        {
                            pklProcessed = pkl;
                        }

                        if (null != pklProcessed && pklProcessed.Count > 0)
                        {
                            DoWritePeakList(rawReader, pklProcessed, fileName, result);
                        }
                    }
                }
                finally
                {
                    if (!bReadAgain)
                    {
                        DoFinalize(bReadAgain, rawReader, fileName, result);
                    }
                }
            }

            if (bReadAgain)
            {
                return(DoProcess(fileName, ignoreScans, lastScan, true));
            }
            else
            {
                return(result);
            }
        }