AnnotatedMSRun.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: Timo Sachsenberg$
// $Authors: David Voigt, Timo Sachsenberg $
// -------------------------------------------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/OpenMSConfig.h>
#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/METADATA/PeptideIdentification.h>
#include <OpenMS/METADATA/PeptideIdentificationList.h>
#include <OpenMS/CONCEPT/HashUtils.h>
#include <boost/range/combine.hpp>
 
#include <functional>
#include <vector>
 
namespace OpenMS
{
  class PeptideIdentification;
 
  class MSSpectrum;
 
  class OPENMS_DLLAPI AnnotatedMSRun
  {
  public:
    using SpectrumIdRef = std::pair<MSSpectrum&, PeptideIdentification&>;
    using ConstSpectrumIdRef = std::pair<const MSSpectrum&, const PeptideIdentification&>;
    using SpectrumType = MSExperiment::SpectrumType;
    using ChromatogramType = MSExperiment::ChromatogramType;
 
 
    AnnotatedMSRun() = default;
 
    explicit AnnotatedMSRun(MSExperiment&& experiment) : data(std::move(experiment))
    {};
 
    AnnotatedMSRun(AnnotatedMSRun&&) = default;
 
    AnnotatedMSRun(const AnnotatedMSRun&) = default;
    AnnotatedMSRun& operator=(const AnnotatedMSRun&) = default;
    AnnotatedMSRun& operator=(AnnotatedMSRun&&) = default;
 
    ~AnnotatedMSRun() = default;
 
    bool operator==(const AnnotatedMSRun& rhs) const
    {
      return data == rhs.data &&
             peptide_ids_ == rhs.peptide_ids_ &&
             protein_ids_ == rhs.protein_ids_;
    }
 
    bool operator!=(const AnnotatedMSRun& rhs) const
    {
      return !(*this == rhs);
    }
 
    std::vector<ProteinIdentification>& getProteinIdentifications()
    {
      return protein_ids_;
    }
 
    const std::vector<ProteinIdentification>& getProteinIdentifications() const
    {
      return protein_ids_;
    }
 
    void setProteinIdentifications(const std::vector<ProteinIdentification>& ids)
    {
      protein_ids_ = ids;
    }
 
    void setProteinIdentifications(std::vector<ProteinIdentification>&& ids)
    {
      protein_ids_ = std::move(ids);
    }
 
    PeptideIdentificationList& getPeptideIdentifications();
    
    const PeptideIdentificationList& getPeptideIdentifications() const;
 
    void setPeptideIdentifications(PeptideIdentificationList&& ids);
 
    void setPeptideIdentifications(const PeptideIdentificationList& ids);
 
    MSExperiment& getMSExperiment();
    
    const MSExperiment& getMSExperiment() const;
 
    void setMSExperiment(MSExperiment&& experiment);
 
    void setMSExperiment(const MSExperiment& experiment);
 
    inline auto cbegin() const
    {
      checkPeptideIdSize_(OPENMS_PRETTY_FUNCTION);
      return PairIterator(data.getSpectra().cbegin(), peptide_ids_.cbegin());
    }
 
    inline auto begin()
    {
      checkPeptideIdSize_(OPENMS_PRETTY_FUNCTION);
      return PairIterator(data.getSpectra().begin(), peptide_ids_.begin());
    }
 
    inline auto begin() const
    {
      checkPeptideIdSize_(OPENMS_PRETTY_FUNCTION);
      return PairIterator(data.getSpectra().cbegin(), peptide_ids_.cbegin());
    }
 
    inline auto end()
    {
      return PairIterator(data.getSpectra().end(), peptide_ids_.end());
    }
 
    inline auto end() const
    {
      return PairIterator(data.getSpectra().end(), peptide_ids_.end());
    }
 
    inline auto cend() const
    {
      return PairIterator(data.getSpectra().cend(), peptide_ids_.cend());
    }
 
    inline SpectrumIdRef operator[](size_t idx)
    {
      if (idx >= peptide_ids_.size())
      {
        throw Exception::IndexOverflow(__FILE__, __LINE__,
          OPENMS_PRETTY_FUNCTION,
          idx, peptide_ids_.size());
      }
      if (idx >= data.getSpectra().size())
      {
        throw Exception::IndexOverflow(__FILE__, __LINE__,
          OPENMS_PRETTY_FUNCTION,
          idx, data.getSpectra().size());
      }      
      return {data.getSpectra()[idx], peptide_ids_[idx]};
    }
 
    inline ConstSpectrumIdRef operator[](size_t idx) const
    {
      if (idx >= peptide_ids_.size())
      {
        throw Exception::IndexOverflow(__FILE__, __LINE__,
          OPENMS_PRETTY_FUNCTION,
          idx, peptide_ids_.size());
      }
      if (idx >= data.getSpectra().size())
      {
        throw Exception::IndexOverflow(__FILE__, __LINE__,
          OPENMS_PRETTY_FUNCTION,
          idx, data.getSpectra().size());
      }
      return {data.getSpectra()[idx], peptide_ids_[idx]};
    }
 
    template<typename T1, typename T2>
    struct PairIterator
    {     
      using iterator_category = std::forward_iterator_tag;
      using difference_type = std::ptrdiff_t;
 
      PairIterator(T1 ptr1, T2 ptr2) : m_ptr1(ptr1), m_ptr2(ptr2)
      {}
 
      PairIterator& operator++()
      {
        ++m_ptr1;
        ++m_ptr2;
        return *this;
      }
 
      PairIterator operator++(int)
      {
        auto tmp(*this);
        ++(*this);
        return tmp;
      }
 
      auto operator*()
      {
        return std::make_pair(std::ref(*m_ptr1), std::ref(*m_ptr2));
      }
 
      inline friend bool operator==(const PairIterator& a, const PairIterator& b)
      {
        return a.m_ptr1 == b.m_ptr1 && a.m_ptr2 == b.m_ptr2;
      }
 
      inline friend bool operator!=(const PairIterator& a, const PairIterator& b)
      {
        return !(a == b);
      }
 
    private:
      T1 m_ptr1;
      T2 m_ptr2;
    };
 
    typedef AnnotatedMSRun::PairIterator<std::vector<MSSpectrum>::iterator, PeptideIdentificationList::iterator> Iterator;
    typedef AnnotatedMSRun::PairIterator<std::vector<MSSpectrum>::const_iterator, PeptideIdentificationList::const_iterator> ConstIterator;
 
  private:
 
    // Helper to enforce invariant
    void checkPeptideIdSize_(const char* function_name) const;
 
    PeptideIdentificationList peptide_ids_;
    std::vector<ProteinIdentification> protein_ids_;
    MSExperiment data;
  };
} // namespace OpenMS
 
// Hash function specialization for AnnotatedMSRun
namespace std
{
  template<>
  struct hash<OpenMS::AnnotatedMSRun>
  {
    std::size_t operator()(const OpenMS::AnnotatedMSRun& run) const noexcept
    {
      // Start with hash of the MSExperiment size (number of spectra)
      std::size_t seed = OpenMS::hash_int(run.getMSExperiment().size());
 
      // Hash the number of chromatograms
      OpenMS::hash_combine(seed, OpenMS::hash_int(run.getMSExperiment().getChromatograms().size()));
 
      // Hash the number of peptide identifications
      OpenMS::hash_combine(seed, OpenMS::hash_int(run.getPeptideIdentifications().size()));
 
      // Hash the number of protein identifications
      OpenMS::hash_combine(seed, OpenMS::hash_int(run.getProteinIdentifications().size()));
 
      // Hash identifying properties from protein identifications
      for (const auto& prot_id : run.getProteinIdentifications())
      {
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(prot_id.getIdentifier()));
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(prot_id.getSearchEngine()));
        OpenMS::hash_combine(seed, OpenMS::hash_int(prot_id.getHits().size()));
      }
 
      // Hash identifying properties from peptide identifications
      for (const auto& pep_id : run.getPeptideIdentifications())
      {
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(pep_id.getIdentifier()));
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(pep_id.getScoreType()));
        OpenMS::hash_combine(seed, OpenMS::hash_int(pep_id.getHits().size()));
        OpenMS::hash_combine(seed, OpenMS::hash_float(pep_id.getSignificanceThreshold()));
      }
 
      // Hash identifying properties from spectra
      for (const auto& spectrum : run.getMSExperiment().getSpectra())
      {
        OpenMS::hash_combine(seed, OpenMS::hash_float(spectrum.getRT()));
        OpenMS::hash_combine(seed, OpenMS::hash_int(spectrum.getMSLevel()));
        OpenMS::hash_combine(seed, OpenMS::hash_int(spectrum.size()));
      }
 
      return seed;
    }
  };
} // namespace std