ThermoRawScanReader.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Julianus Pfeuffer $
// $Authors: Julianus Pfeuffer $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/FORMAT/ThermoRawFile.h>
#include <OpenMS/FORMAT/HANDLERS/ThermoRawFileMetadata.h>
 
#include <algorithm>
#include <cmath>
#include <limits>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace OpenMS
{
  class DataProcessing;
  class ExperimentalSettings;
  class MSChromatogram;
  class MSSpectrum;
 
namespace Internal
{
  class OPENMS_DLLAPI ThermoRawScanReader
  {
  public:
    using Options = ThermoRawFile::Options;
 
    struct ScanInfo
    {
      int scan = 0;          
      int ms_level = 0;      
      double rt = 0.0;       
      double tic = 0.0;      
      double precursor_mz = 0.0; 
    };
 
    struct ScanRecord
    {
      ScanInfo info;
      std::vector<ThermoPrecursor> precursors; 
      std::string configuration_id;            
      std::string native_id;
    };
 
    class OPENMS_DLLAPI Accessor
    {
    public:
      ~Accessor();
      Accessor(const Accessor&) = delete;
      Accessor& operator=(const Accessor&) = delete;
 
      void convert(const ScanRecord& record, MSSpectrum& spectrum, bool peaks);
 
      void readPeaks(int scan, MSSpectrum& spectrum);
 
      std::unique_ptr<Accessor> clone() const;
 
    private:
      friend class ThermoRawScanReader;
      struct Impl;
      explicit Accessor(std::unique_ptr<Impl> impl);
      std::unique_ptr<Impl> impl_;
    };
 
    using ParentLookup = std::function<const MSSpectrum*(int scan)>;
 
    ThermoRawScanReader(const std::string& path, const Options& options);
    ~ThermoRawScanReader();
    ThermoRawScanReader(const ThermoRawScanReader&) = delete;
    ThermoRawScanReader& operator=(const ThermoRawScanReader&) = delete;
 
    bool hasMSData() const;
    int firstScan() const;
    int lastScan() const;
 
    void fillSettings(ExperimentalSettings& settings) const;
 
    const ScanInfo& header(int scan, bool with_peaks = false);
 
    void readAhead(int last_scan, int peaks_from);
 
    void scanHeaders(int first, int last, bool precursors, const std::function<bool(const ScanInfo&)>& visit);
 
    void convert(MSSpectrum& spectrum, ExperimentalSettings& settings, const ParentLookup& parent, bool peaks);
 
    void addInstrumentConfigurations(ExperimentalSettings& settings);
 
    ScanRecord record() const;
 
    std::unique_ptr<Accessor> accessor() const;
 
    std::shared_ptr<DataProcessing> dataProcessing() const;
 
    MSChromatogram ticChromatogram() const;
 
    void readDetectors(std::vector<MSChromatogram>& chromatograms, std::vector<MSSpectrum>& spectra);
 
  private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
  };
  struct ThermoRawScanSelection
  {
    const ThermoRawFile::Options& options;
 
    bool level(int level) const
    {
      return options.ms_levels.empty() || std::find(options.ms_levels.begin(), options.ms_levels.end(), level) != options.ms_levels.end();
    }
    bool rt(double rt) const { return rt >= options.rt_min && rt < options.rt_max; }
    bool precursorFiltered() const
    {
      return options.precursor_mz_min > -std::numeric_limits<double>::infinity() || options.precursor_mz_max < std::numeric_limits<double>::infinity();
    }
    bool headerFiltered() const
    {
      return ! options.ms_levels.empty() || precursorFiltered() || options.rt_min > -std::numeric_limits<double>::infinity()
             || options.rt_max < std::numeric_limits<double>::infinity();
    }
    int lastScan(int last) const { return options.last_scan > 0 ? std::min(last, options.last_scan) : last; }
    bool beyondRT(const ThermoRawScanReader::ScanInfo& info) const { return info.rt >= options.rt_max; }
    bool selected(const ThermoRawScanReader::ScanInfo& info) const
    {
      if (info.scan < options.first_scan || ! rt(info.rt) || ! level(info.ms_level)) { return false; }
      return info.ms_level <= 1 || std::isnan(info.precursor_mz)
             || (info.precursor_mz >= options.precursor_mz_min && info.precursor_mz < options.precursor_mz_max);
    }
  };
 
} // namespace Internal
} // namespace OpenMS