PeptideAndProteinQuant.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/DATASTRUCTURES/DefaultParamHandler.h>
#include <OpenMS/KERNEL/ConsensusMap.h>
#include <OpenMS/KERNEL/FeatureMap.h>
#include <OpenMS/METADATA/PeptideIdentification.h>
#include <OpenMS/METADATA/PeptideIdentificationList.h>
#include <OpenMS/METADATA/ProteinIdentification.h>
#include <OpenMS/METADATA/ExperimentalDesign.h>
 
#include <map>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace OpenMS
{
  class OPENMS_DLLAPI PeptideAndProteinQuant :
    public DefaultParamHandler
  {
public:
 
    typedef std::map<UInt64, double> SampleAbundances;
 
    struct PeptideData
    {
      std::map<Int, std::map<std::string, std::map<Int, std::map<UInt, double>>>> abundances;
 
      std::map<Int, std::map<std::string, std::map<Int, UInt64>>> psm_counts;
 
      SampleAbundances total_abundances;
 
      SampleAbundances total_psm_counts;
 
      std::set<std::string> accessions;
 
      Size psm_count = 0;
 
      PeptideData() = default;
    };
 
    typedef std::map<AASequence, PeptideData> PeptideQuant;
 
    struct ProteinData
    {
      std::map<std::string, SampleAbundances> peptide_abundances;
 
      std::map<std::string, SampleAbundances> peptide_psm_counts;
 
      std::map<std::string, std::map<UInt, double>> channel_level_abundances;
 
      std::map<std::string, UInt64> file_level_psm_counts;
 
      SampleAbundances total_abundances;
 
      SampleAbundances total_psm_counts;
 
      SampleAbundances total_distinct_peptides;
 
      Size psm_count = 0;
 
      ProteinData() = default;
    };
 
    typedef std::map<std::string, ProteinData> ProteinQuant;
 
    struct Statistics
    {
      Size n_samples;
 
      Size n_fractions;
 
      Size n_ms_files;
 
      Size quant_proteins, too_few_peptides;
 
      Size quant_peptides, total_peptides;
 
      Size quant_features, total_features, blank_features, ambig_features;
 
      Statistics() :
        n_samples(0), quant_proteins(0), too_few_peptides(0),
        quant_peptides(0), total_peptides(0), quant_features(0),
        total_features(0), blank_features(0), ambig_features(0) {}
    };
 
    PeptideAndProteinQuant();
 
    ~PeptideAndProteinQuant() override {}
 
    void readQuantData(FeatureMap& features, const ExperimentalDesign& ed);
 
    void readQuantData(ConsensusMap& consensus, const ExperimentalDesign& ed);
 
    void readQuantData(std::vector<ProteinIdentification>& proteins,
                       PeptideIdentificationList& peptides,
                       const ExperimentalDesign& ed);
 
    void quantifyPeptides(const PeptideIdentificationList& peptides =
                          PeptideIdentificationList());
 
 
    void quantifyProteins(const ProteinIdentification& proteins = ProteinIdentification());
 
 
    std::map<std::string, std::string> mapAccessionToLeader(const OpenMS::ProteinIdentification& proteins) const;
 
    const Statistics& getStatistics();
 
    const PeptideQuant& getPeptideResults();
 
    const ProteinQuant& getProteinResults();
 
    void annotateQuantificationsToProteins(
      const ProteinQuant& protein_quants, 
      ProteinIdentification& proteins,
      bool remove_unquantified = true);
 
private:
 
    struct FileLabelHash
    {
      std::size_t operator()(const std::pair<std::string, UInt>& p) const noexcept
      {
        const std::size_t h1 = std::hash<std::string>{}(p.first);
        const std::size_t h2 = std::hash<UInt>{}(p.second);
        // boost-style hash_combine
        return h1 ^ (h2 + 0x9e3779b97f4a7c15ULL + (h1 << 6) + (h1 >> 2));
      }
    };
 
    typedef std::unordered_map<std::string, std::vector<const PeptideQuant::value_type*>> UnmodifiedToEntriesIndex;
 
    Statistics stats_;
 
    PeptideQuant pep_quant_;
 
    ProteinQuant prot_quant_;
 
    ExperimentalDesign experimental_design_;
 
    std::unordered_map<std::pair<std::string, UInt>, size_t, FileLabelHash> sample_id_lookup_;
 
 
    PeptideHit getAnnotation_(PeptideIdentificationList& peptides);
 
    void quantifyFeature_(const FeatureHandle& feature,
      size_t fraction,
      const std::string& filename,
      const PeptideHit& hit,
      UInt channel_or_label);
 
    bool getBest_(
      const std::map<Int, std::map<std::string, std::map<Int, std::map<UInt, double>>>> & peptide_abundances,
      std::tuple<size_t, std::string, size_t, UInt> & best);
 
    template <typename T>
    void orderBest_(const std::map<T, SampleAbundances> & abundances,
                    std::vector<T>& result)
    {
      typedef std::pair<Size, double> PairType;
      std::multimap<PairType, T, std::greater<PairType> > order;
      for (typename std::map<T, SampleAbundances>::const_iterator ab_it =
             abundances.begin(); ab_it != abundances.end(); ++ab_it)
      {
        double total = 0.0;
        for (SampleAbundances::const_iterator samp_it = ab_it->second.begin();
             samp_it != ab_it->second.end(); ++samp_it)
        {
          total += samp_it->second;
        }
        if (total <= 0.0) continue;         // not quantified
        PairType key = std::make_pair(ab_it->second.size(), total);
        order.insert(std::make_pair(key, ab_it->first));
      }
      result.clear();
      for (typename std::multimap<PairType, T, std::greater<PairType> >::
           iterator ord_it = order.begin(); ord_it != order.end(); ++ord_it)
      {
        result.push_back(ord_it->second);
      }
    }
 
 
 
    void normalizePeptides_();
 
    void transferPeptideDataToProteins_(const ProteinIdentification& proteins);
 
    std::vector<std::string> selectPeptidesForQuantification_(const std::string& protein_accession,
                                                        Size top_n,
                                                        bool fix_peptides);
 
    double aggregateAbundances_(const std::vector<double>& abundances,
                               const std::string& method) const;
 
    void calculateProteinAbundances_(const std::string& protein_accession,
                                    const std::vector<std::string>& selected_peptides,
                                    const std::string& aggregate_method,
                                    Size top_n,
                                    bool include_all);
 
    void calculateFileAndChannelLevelProteinAbundances_(const std::string& protein_accession,
                                           const std::vector<std::string>& selected_peptides,
                                           const std::string& aggregate_method,
                                           Size top_n,
                                           bool include_all,
                                           const std::map<std::string, std::string>& accession_to_leader,
                                           const UnmodifiedToEntriesIndex& unmod_to_entries);
 
    void performIbaqNormalization_(const ProteinIdentification& proteins);
 
    std::string getAccession_(const std::set<std::string>& pep_accessions,
                         const std::map<std::string, std::string>& accession_to_leader) const;
 
    void countPeptides_(PeptideIdentificationList& peptides);
 
    void buildSampleIDLookup_();
 
    size_t getSampleIDFromFilenameAndChannel_(const std::string& filename,
                                           UInt channel_or_label) const;
 
    void updateMembers_() override;
 
  };   // class
 
} // namespace