SpectrumMetaDataLookup.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: Hendrik Weisser $
// $Authors: Hendrik Weisser $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/METADATA/SpectrumLookup.h>
 
#include <OpenMS/FORMAT/FileHandler.h>
#include <OpenMS/KERNEL/MSSpectrum.h>
#include <OpenMS/METADATA/ProteinIdentification.h>
#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/METADATA/PeptideIdentificationList.h>
 
#include <limits> // for "quiet_NaN"
 
namespace OpenMS
{
 
  class OPENMS_DLLAPI SpectrumMetaDataLookup: public SpectrumLookup
  {
  public:
 
    typedef unsigned char MetaDataFlags;
 
    static const MetaDataFlags MDF_RT = 1;
    static const MetaDataFlags MDF_PRECURSORRT = 2;
    static const MetaDataFlags MDF_PRECURSORMZ = 4;
    static const MetaDataFlags MDF_PRECURSORCHARGE = 8;
    static const MetaDataFlags MDF_MSLEVEL = 16;
    static const MetaDataFlags MDF_SCANNUMBER = 32;
    static const MetaDataFlags MDF_NATIVEID = 64;
    static const MetaDataFlags MDF_ALL = 127;
 
 
    struct SpectrumMetaData
    {
      double rt; 
      double precursor_rt; 
      double precursor_mz; 
      Int precursor_charge; 
      Size ms_level; 
      Int scan_number; 
      String native_id; 
 
      SpectrumMetaData():
        rt(std::numeric_limits<double>::quiet_NaN()), 
        precursor_rt(std::numeric_limits<double>::quiet_NaN()), 
        precursor_mz(std::numeric_limits<double>::quiet_NaN()),
        precursor_charge(0), ms_level(0), scan_number(-1), native_id("")
      {
      }
 
      SpectrumMetaData(const SpectrumMetaData &) = default;
      SpectrumMetaData(SpectrumMetaData&&) = default;
      ~SpectrumMetaData() = default;
 
      SpectrumMetaData & operator=(const SpectrumMetaData &) = default;
      SpectrumMetaData& operator=(SpectrumMetaData&&) & = default;
    };
 
    SpectrumMetaDataLookup(): SpectrumLookup()
    {}
 
    ~SpectrumMetaDataLookup() override {}
 
    template <typename SpectrumContainer>
    void readSpectra(const SpectrumContainer& spectra,
                     const String& scan_regexp = default_scan_regexp,
                     bool get_precursor_rt = false)
    {
      // If class SpectrumContainer is e.g. OnDiscMSExperiment, reading each
      // spectrum is expensive. Thus, to avoid iterating over all spectra twice,
      // we do not call "SpectrumLookup::readSpectra" here:
      n_spectra_ = spectra.size();
      metadata_.reserve(n_spectra_);
      setScanRegExp_(scan_regexp);
      // mapping: MS level -> RT of previous spectrum of that level
      std::map<Size, double> precursor_rts;
      for (Size i = 0; i < n_spectra_; ++i)
      {
        const MSSpectrum& spectrum = spectra[i];
        SpectrumMetaData meta;
        getSpectrumMetaData(spectrum, meta, scan_regexp_, precursor_rts);
        if (get_precursor_rt) precursor_rts[meta.ms_level] = meta.rt;
        addEntry_(i, meta.rt, meta.scan_number, meta.native_id);
        metadata_.push_back(meta);
      }
    }
 
 
    void setSpectraDataRef(const String& spectra_data)
    {
      this->spectra_data_ref = spectra_data;
    }
 
 
    void getSpectrumMetaData(Size index, SpectrumMetaData& meta) const;
 
    static void getSpectrumMetaData(
      const MSSpectrum& spectrum, SpectrumMetaData& meta,
      const boost::regex& scan_regexp = boost::regex(),
      const std::map<Size, double>& precursor_rts = (std::map<Size, double>()));
 
    void getSpectrumMetaData(const String& spectrum_ref, SpectrumMetaData& meta,
                             MetaDataFlags flags = MDF_ALL) const;
 
  static bool addMissingRTsToPeptideIDs(PeptideIdentificationList& peptides, const MSExperiment& exp);
 
    static bool addMissingIMToPeptideIDs(PeptideIdentificationList& peptides,
                      const MSExperiment& exp);
 
    static bool addMissingFAIMSToPeptideIDs(PeptideIdentificationList& peptides,
                                            const MSExperiment& exp);
 
    static bool addMissingSpectrumReferences(PeptideIdentificationList& peptides, 
      const String& filename,
      bool stop_on_error = false, 
      bool override_spectra_data = false, 
      bool override_spectra_references = false, 
      std::vector<ProteinIdentification> proteins = std::vector<ProteinIdentification>());
 
 
 
  protected:
 
    std::vector<SpectrumMetaData> metadata_; 
    String spectra_data_ref;
 
  private:
 
    SpectrumMetaDataLookup(const SpectrumMetaDataLookup&);
 
    SpectrumMetaDataLookup& operator=(const SpectrumMetaDataLookup&);
 
  };
 
} //namespace OpenMS