ProteinIdentification.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: Chris Bielow $
// $Authors: Nico Pfeifer, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/METADATA/ProteinHit.h>
#include <OpenMS/METADATA/IdentifierMSRunMapper.h>
#include <OpenMS/METADATA/MetaInfoInterface.h>
#include <OpenMS/DATASTRUCTURES/DateTime.h>
#include <OpenMS/CHEMISTRY/DigestionEnzymeProtein.h>
#include <OpenMS/CHEMISTRY/EnzymaticDigestion.h>
#include <OpenMS/METADATA/DataArrays.h>
#include <OpenMS/CONCEPT/HashUtils.h>
#include <OpenMS/DATASTRUCTURES/ListUtils.h>
#include <OpenMS/CONCEPT/Exception.h>
 
#include <functional>
#include <set>
#include <algorithm>
 
namespace OpenMS
{
  class MSExperiment;
  class PeptideIdentification;
  class PeptideIdentificationList;
  class PeptideEvidence;
  class ConsensusMap;
 
  class OPENMS_DLLAPI ProteinIdentification :
    public MetaInfoInterface
  {
public:
    typedef ProteinHit HitType;
 
    using Mapping = IdentifierMSRunMapper;
 
    class OPENMS_DLLAPI ProteinGroup
    {
    public:
      typedef OpenMS::DataArrays::FloatDataArray FloatDataArray ;
      typedef std::vector<FloatDataArray> FloatDataArrays;
      typedef OpenMS::DataArrays::StringDataArray StringDataArray ;
      typedef std::vector<StringDataArray> StringDataArrays;
      typedef OpenMS::DataArrays::IntegerDataArray IntegerDataArray ;
      typedef std::vector<IntegerDataArray> IntegerDataArrays;
 
      double probability;
 
      std::vector<std::string> accessions;
 
      ProteinGroup();
 
      bool operator==(const ProteinGroup& rhs) const;
 
      /*
        @brief Comparison operator (for sorting)
 
        This operator is intended for sorting protein groups in a "best first"
        manner. That means higher probabilities are "less" than lower
        probabilities (!); smaller groups are "less" than larger groups;
        everything else being equal, accessions are compared lexicographically.
      */
      bool operator<(const ProteinGroup& rhs) const;
 
 
      const FloatDataArrays& getFloatDataArrays() const;
 
      FloatDataArrays& getFloatDataArrays()
      {
        return float_data_arrays_;
      }
 
      void setFloatDataArrays(const FloatDataArrays& fda);
 
      const StringDataArrays& getStringDataArrays() const;
 
      StringDataArrays& getStringDataArrays();
 
      void setStringDataArrays(const StringDataArrays& sda);
 
      const IntegerDataArrays& getIntegerDataArrays() const;
 
      IntegerDataArrays& getIntegerDataArrays();
 
      void setIntegerDataArrays(const IntegerDataArrays& ida);
 
      inline IntegerDataArray& getIntegerDataArrayByName(const std::string& name)
      {
        auto it = std::find_if(integer_data_arrays_.begin(), integer_data_arrays_.end(),
          [&name](const IntegerDataArray& da) { return da.getName() == name; } );
        if (it == integer_data_arrays_.end())
        {
          throw Exception::ElementNotFound(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,std::string("IntegerDataArray: ") + name);
        }
        return *it;
      }
 
      inline StringDataArray& getStringDataArrayByName(const std::string& name)
      {
        auto it = std::find_if(string_data_arrays_.begin(), string_data_arrays_.end(),
          [&name](const StringDataArray& da) { return da.getName() == name; } );
        if (it == string_data_arrays_.end())
        {
          throw Exception::ElementNotFound(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,std::string("StringDataArray: ") + name);
        }
        return *it;
      }
 
      inline FloatDataArray& getFloatDataArrayByName(const std::string& name)
      {
        auto it = std::find_if(float_data_arrays_.begin(), float_data_arrays_.end(),
          [&name](const FloatDataArray& da) { return da.getName() == name; } );
        if (it == float_data_arrays_.end())
        {
          throw Exception::ElementNotFound(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,std::string("FloatDataArray: ") + name);
        }
        return *it;
      }
 
      inline const IntegerDataArray& getIntegerDataArrayByName(const std::string& name) const
      {
        auto it = std::find_if(integer_data_arrays_.begin(), integer_data_arrays_.end(),
          [&name](const IntegerDataArray& da) { return da.getName() == name; } );
        if (it == integer_data_arrays_.end())
        {
          throw Exception::ElementNotFound(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,std::string("IntegerDataArray: ") + name);
        }
        return *it;
      }
 
      inline const StringDataArray& getStringDataArrayByName(const std::string& name) const
      {
        auto it = std::find_if(string_data_arrays_.begin(), string_data_arrays_.end(),
          [&name](const StringDataArray& da) { return da.getName() == name; } );
        if (it == string_data_arrays_.end())
        {
          throw Exception::ElementNotFound(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,std::string("StringDataArray: ") + name);
        }
        return *it;
      }
 
      inline const FloatDataArray& getFloatDataArrayByName(const std::string& name) const
      {
        auto it = std::find_if(float_data_arrays_.begin(), float_data_arrays_.end(),
          [&name](const FloatDataArray& da) { return da.getName() == name; } );
        if (it == float_data_arrays_.end())
        {
          throw Exception::ElementNotFound(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,std::string("FloatDataArray: ") + name);
        }
        return *it;
      }
 
    private:
      FloatDataArrays float_data_arrays_;
 
      StringDataArrays string_data_arrays_;
 
      IntegerDataArrays integer_data_arrays_;
    };
 
    enum class PeakMassType
    {
      MONOISOTOPIC,
      AVERAGE,
      SIZE_OF_PEAKMASSTYPE
    };
 
    static const std::string NamesOfPeakMassType[static_cast<size_t>(PeakMassType::SIZE_OF_PEAKMASSTYPE)];
 
    static StringList getAllNamesOfPeakMassType();
 
    struct OPENMS_DLLAPI SearchParameters :
      public MetaInfoInterface
    {
      std::string db; 
      std::string db_version; 
      std::string taxonomy; 
      std::string charges; 
      PeakMassType mass_type; 
      std::vector<std::string> fixed_modifications; 
      std::vector<std::string> variable_modifications; 
      UInt missed_cleavages; 
      double fragment_mass_tolerance; 
      bool fragment_mass_tolerance_ppm; 
      double precursor_mass_tolerance; 
      bool precursor_mass_tolerance_ppm; 
      Protease digestion_enzyme; 
      EnzymaticDigestion::Specificity enzyme_term_specificity; 
 
      SearchParameters();
      SearchParameters(const SearchParameters&) = default;
      SearchParameters(SearchParameters&&) = default;
      ~SearchParameters() = default;
 
      SearchParameters& operator=(const SearchParameters&) = default;
      SearchParameters& operator=(SearchParameters&&)& = default;
 
      bool operator==(const SearchParameters& rhs) const;
 
      bool operator!=(const SearchParameters& rhs) const;
 
      std::pair<int,int> getChargeRange() const;
 
      bool mergeable(const ProteinIdentification::SearchParameters& sp, const std::string& experiment_type) const;
 
      private:
      int getChargeValue_(std::string& charge_str) const;
    };
 
    ProteinIdentification();
    ProteinIdentification(const ProteinIdentification&) = default;
    ProteinIdentification(ProteinIdentification&&) = default;
    virtual ~ProteinIdentification();
 
    ProteinIdentification& operator=(const ProteinIdentification&) = default;
    ProteinIdentification& operator=(ProteinIdentification&&) = default;
 
    bool operator==(const ProteinIdentification& rhs) const;
    bool operator!=(const ProteinIdentification& rhs) const;
 
 
 
    const std::vector<ProteinHit>& getHits() const;
    std::vector<ProteinHit>& getHits();
    void insertHit(const ProteinHit& input);
    void insertHit(ProteinHit&& input);
 
    void setHits(const std::vector<ProteinHit>& hits);
 
    std::vector<ProteinHit>::iterator findHit(const std::string& accession);
 
    const std::vector<ProteinGroup>& getProteinGroups() const;
    std::vector<ProteinGroup>& getProteinGroups();
    void insertProteinGroup(const ProteinGroup& group);
 
    const std::vector<ProteinGroup>& getIndistinguishableProteins() const;
    std::vector<ProteinGroup>& getIndistinguishableProteins();
    void insertIndistinguishableProteins(const ProteinGroup& group);
    void fillIndistinguishableGroupsWithSingletons();
 
    double getSignificanceThreshold() const;
    void setSignificanceThreshold(double value);
    const std::string& getScoreType() const;
    void setScoreType(const std::string& type);
    bool isHigherScoreBetter() const;
    void setHigherScoreBetter(bool higher_is_better);
    void sort();
 
    void computeCoverage(const PeptideIdentificationList& pep_ids);
    void computeCoverage(const ConsensusMap& cmap, bool use_unassigned_ids);
 
    void computeModifications(
      const PeptideIdentificationList& pep_ids,
      const StringList& skip_modifications);
    void computeModifications(
      const ConsensusMap& cmap,
      const StringList& skip_modifications,
      bool use_unassigned_ids);
 
 
 
 
    const DateTime& getDateTime() const;
    void setDateTime(const DateTime& date);
    void setSearchEngine(const std::string& search_engine);
    const std::string& getSearchEngine() const;
    const std::string getOriginalSearchEngineName() const;
    void setSearchEngineVersion(const std::string& search_engine_version);
    const std::string& getSearchEngineVersion() const;
    void setInferenceEngine(const std::string& search_engine);
    const std::string getInferenceEngine() const;
    void setInferenceEngineVersion(const std::string& inference_engine_version);
    const std::string getInferenceEngineVersion() const;
    void setSearchParameters(const SearchParameters& search_parameters);
    void setSearchParameters(SearchParameters&& search_parameters);
    const SearchParameters& getSearchParameters() const;
    SearchParameters& getSearchParameters();
    const std::string& getIdentifier() const;
    void setIdentifier(const std::string& id);
    void setPrimaryMSRunPath(const StringList& s, bool raw = false);
 
    void setPrimaryMSRunPath(const StringList& s, MSExperiment& e);
    void addPrimaryMSRunPath(const std::string& s, bool raw = false);
    void addPrimaryMSRunPath(const StringList& s, bool raw = false);
 
    void getPrimaryMSRunPath(StringList& output, bool raw = false) const;
 
    Size nrPrimaryMSRunPaths(bool raw = false) const;
 
    bool hasInferenceData() const;
 
    bool hasInferenceEngineAsSearchEngine() const;
 
    bool peptideIDsMergeable(const ProteinIdentification& id_run, const std::string& experiment_type) const;
 
    std::vector<std::pair<std::string, std::string>> getSearchEngineSettingsAsPairs(const std::string& se = "") const;
 
 
    void copyMetaDataOnly(const ProteinIdentification&);
protected:
 
    std::string id_;
    std::string search_engine_;
    std::string search_engine_version_;
    SearchParameters search_parameters_;
    DateTime date_;
 
 
    std::string protein_score_type_;
    bool higher_score_better_;
    std::vector<ProteinHit> protein_hits_;
    std::vector<ProteinGroup> protein_groups_;
    std::vector<ProteinGroup> indistinguishable_proteins_;
    double protein_significance_threshold_;
 
  private:
    void computeCoverageFromEvidenceMapping_(const std::unordered_map<std::string, std::set<PeptideEvidence>>& map);
    void fillEvidenceMapping_(std::unordered_map<std::string, std::set<PeptideEvidence> >& map_acc_2_evidence,
                              const PeptideIdentificationList& pep_ids) const;
 
    void fillModMapping_(const PeptideIdentificationList& pep_ids, const StringList& skip_modifications,
                         std::unordered_map<std::string, std::set<std::pair<Size, ResidueModification>>>& prot2mod) const;
  };
 
 
} //namespace OpenMS
 
// Hash function specializations
namespace std
{
  template<>
  struct hash<OpenMS::ProteinIdentification::ProteinGroup>
  {
    std::size_t operator()(const OpenMS::ProteinIdentification::ProteinGroup& pg) const noexcept
    {
      std::size_t seed = OpenMS::hash_float(pg.probability);
      for (const auto& acc : pg.accessions)
      {
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(acc));
      }
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::ProteinIdentification::SearchParameters>
  {
    std::size_t operator()(const OpenMS::ProteinIdentification::SearchParameters& sp) const noexcept
    {
      std::size_t seed = OpenMS::fnv1a_hash_string(sp.db);
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(sp.db_version));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(sp.taxonomy));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(sp.charges));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(sp.mass_type)));
      // Hash fixed_modifications
      for (const auto& mod : sp.fixed_modifications)
      {
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(mod));
      }
      // Hash variable_modifications
      for (const auto& mod : sp.variable_modifications)
      {
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(mod));
      }
      OpenMS::hash_combine(seed, OpenMS::hash_int(sp.missed_cleavages));
      OpenMS::hash_combine(seed, OpenMS::hash_float(sp.fragment_mass_tolerance));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(sp.fragment_mass_tolerance_ppm)));
      OpenMS::hash_combine(seed, OpenMS::hash_float(sp.precursor_mass_tolerance));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(sp.precursor_mass_tolerance_ppm)));
      // Hash digestion_enzyme using the base class hash
      OpenMS::hash_combine(seed, std::hash<OpenMS::DigestionEnzyme>{}(sp.digestion_enzyme));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(sp.enzyme_term_specificity)));
      // Hash MetaInfoInterface base class
      OpenMS::hash_combine(seed, std::hash<OpenMS::MetaInfoInterface>{}(sp));
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::ProteinIdentification>
  {
    std::size_t operator()(const OpenMS::ProteinIdentification& pi) const noexcept
    {
      // Hash identifier and search engine info
      std::size_t seed = OpenMS::fnv1a_hash_string(pi.getIdentifier());
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(pi.getSearchEngine()));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(pi.getSearchEngineVersion()));
      // Hash SearchParameters
      OpenMS::hash_combine(seed, std::hash<OpenMS::ProteinIdentification::SearchParameters>{}(pi.getSearchParameters()));
      // Hash DateTime
      OpenMS::hash_combine(seed, std::hash<OpenMS::DateTime>{}(pi.getDateTime()));
      // Hash protein_hits
      for (const auto& hit : pi.getHits())
      {
        OpenMS::hash_combine(seed, OpenMS::hash_float(hit.getScore()));
        OpenMS::hash_combine(seed, OpenMS::hash_int(hit.getRank()));
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(hit.getAccession()));
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(hit.getSequence()));
        OpenMS::hash_combine(seed, OpenMS::hash_float(hit.getCoverage()));
      }
      // Hash protein_groups
      for (const auto& group : pi.getProteinGroups())
      {
        OpenMS::hash_combine(seed, std::hash<OpenMS::ProteinIdentification::ProteinGroup>{}(group));
      }
      // Hash indistinguishable_proteins
      for (const auto& group : pi.getIndistinguishableProteins())
      {
        OpenMS::hash_combine(seed, std::hash<OpenMS::ProteinIdentification::ProteinGroup>{}(group));
      }
      // Hash score type and threshold
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(pi.getScoreType()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(pi.getSignificanceThreshold()));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(pi.isHigherScoreBetter())));
      // Hash MetaInfoInterface base class
      OpenMS::hash_combine(seed, std::hash<OpenMS::MetaInfoInterface>{}(pi));
      return seed;
    }
  };
} // namespace std