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 <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace OpenMS
{
  class OPENMS_DLLAPI PeptideAndProteinQuant :
    public DefaultParamHandler
  {
public:
 
    typedef std::map<UInt64, double> SampleAbundances;
 
    typedef std::map<UInt, std::map<UInt, double>> FractionGroupAbundances;
 
    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;
 
      FractionGroupAbundances fraction_group_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, FractionGroupAbundances> peptide_fraction_group_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;
 
      FractionGroupAbundances fraction_group_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));
      }
    };
 
    struct DesignCell
    {
      Size sample = 0;
      UInt fraction_group = 0;
    };
 
    typedef std::unordered_map<std::string, std::vector<const PeptideQuant::value_type*>> UnmodifiedToEntriesIndex;
 
    Statistics stats_;
 
    PeptideQuant pep_quant_;
 
    std::map<AASequence, Int> best_charge_by_peptidoform_;
 
    ProteinQuant prot_quant_;
 
    ExperimentalDesign experimental_design_;
 
    std::unordered_map<std::pair<std::string, UInt>, DesignCell, FileLabelHash> design_cell_lookup_;
 
    std::set<std::pair<UInt, UInt>> quantification_fraction_group_labels_;
 
 
    PeptideHit getAnnotation_(PeptideIdentificationList& peptides);
 
    void quantifyFeature_(const FeatureHandle& feature,
      size_t fraction,
      const std::string& filename,
      const PeptideHit& hit,
      UInt channel_or_label);
 
    bool getBestCharge_(
      const std::map<Int, std::map<std::string, std::map<Int, std::map<UInt, double>>>>& peptide_abundances,
      Int& best_charge) const;
 
    typedef std::map<UInt, std::map<Int, std::map<UInt, double>>> FractionGroupFractionAbundances;
 
    static Int selectBestFraction_(const std::map<Int, std::map<UInt, double>>& fraction_abundances);
 
    void collapseFractions_(const FractionGroupFractionAbundances& fraction_abundances,
                            FractionGroupAbundances& assay_abundances) const;
 
    static Size countQuantifiedAssays_(const FractionGroupAbundances& abundances);
 
    template <typename T>
    void orderBest_(const std::map<T, FractionGroupAbundances>& abundances,
                    std::vector<T>& result)
    {
      typedef std::pair<Size, double> PairType;
      std::multimap<PairType, T, std::greater<PairType> > order;
      for (const auto& abundance : abundances)
      {
        double total = 0.0;
        for (const auto& [fraction_group, label_abundances] : abundance.second)
        {
          (void)fraction_group;
          for (const auto& label_abundance : label_abundances)
          {
            total += label_abundance.second;
          }
        }
        if (total <= 0.0) continue;         // not quantified
        PairType key = std::make_pair(countQuantifiedAssays_(abundance.second), total);
        order.insert(std::make_pair(key, abundance.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 calculateFractionGroupLevelProteinAbundances_(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_();
 
    const DesignCell& getDesignCellFromFilenameAndChannel_(const std::string& filename,
                                                           UInt channel_or_label) const;
 
    Size getSampleIDFromFilenameAndChannel_(const std::string& filename,
                                            UInt channel_or_label) const;
 
    void updateMembers_() override;
 
  };   // class
 
} // namespace