Percolator.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: Timo Sachsenberg $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/ANALYSIS/ID/PercolatorReset.h>
#include <OpenMS/ANALYSIS/ID/PercolatorTypes.h>
#include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
#include <OpenMS/METADATA/PeptideIdentification.h>
#include <OpenMS/METADATA/PeptideIdentificationList.h>
#include <OpenMS/METADATA/ProteinIdentification.h>
 
#include <functional>
#include <memory>
#include <utility>
#include <vector>
 
namespace OpenMS
{
  class OPENMS_DLLAPI Percolator : public DefaultParamHandler
  {
  public:
    Percolator();
    ~Percolator() override;
 
    Percolator(const Percolator&) = delete;
    Percolator& operator=(const Percolator&) = delete;
 
    void rescore(std::vector<PeptideIdentification>& peptide_ids,
                 const StringList& feature_names = {});
 
    RescoreOutput rescore(const RescoreInput& input);
 
    Size rescorePSMs(PeptideIdentificationList& peptide_ids,
                     const StringList& feature_set,
                     const std::string& enzyme,
                     int min_charge,
                     int max_charge,
                     const std::string& score_type = "q-value",
                     bool best_hit_only = false);
 
    using PSMRowLocations = std::vector<std::pair<size_t, size_t>>;
 
    static void buildPSMRescoreInput(const PeptideIdentificationList& peptide_ids,
                                     const StringList& feature_set,
                                     const std::string& enzyme,
                                     int min_charge,
                                     int max_charge,
                                     RescoreInput& input,
                                     PSMRowLocations& rows,
                                     bool calc_mass_feature = false);
 
    using PSMScorer = std::function<RescoreOutput(const RescoreInput&, const PSMRowLocations&)>;
 
    Size rescorePSMsWithScorer(PeptideIdentificationList& peptide_ids,
                               const StringList& feature_set,
                               const std::string& enzyme,
                               int min_charge,
                               int max_charge,
                               const std::string& score_type,
                               const PSMScorer& scorer,
                               bool best_hit_only = false);
 
    PercolatorModel trainPSMs(PeptideIdentificationList& peptide_ids,
                              const StringList& feature_set,
                              const std::string& enzyme,
                              int min_charge,
                              int max_charge);
 
    Size scorePSMs(PeptideIdentificationList& peptide_ids,
                   const PercolatorModel& model,
                   PeptideIdentificationList& reference_ids,
                   const StringList& feature_set,
                   const std::string& enzyme,
                   int min_charge,
                   int max_charge,
                   const std::string& score_type = "q-value");
 
    const std::vector<std::vector<double>>& getSvmWeights() const;
 
    void storeWeights(const std::string& filename) const;
 
    static constexpr const char* VENDORED_VERSION = "3.08-vendored";
 
    static void markRescoredRuns(std::vector<ProteinIdentification>& runs,
                                 const std::string& tool,
                                 const std::vector<std::pair<std::string, DataValue>>& settings,
                                 const std::string& version = VENDORED_VERSION);
 
    struct CappedTrainingInfo
    {
      std::vector<int> fold;                          
      std::vector<char> sampled;                      
      std::vector<std::vector<size_t>> trained_rows;  
      std::vector<int> scorer;                        
      // subset_mode 'learning_curve':
      size_t validation_rows = 0;                     
      std::vector<size_t> curve_sizes;                
      std::vector<std::vector<long>> curve_counts;    
      std::vector<std::vector<long>> curve_discordant; 
      std::vector<size_t> chosen_size;                
    };
 
    const CappedTrainingInfo& getCappedTrainingInfo() const;
 
    double getPi0() const;
 
    bool usedDefaultDirection() const;
 
    PercolatorModel train(const RescoreInput& input);
 
    RescoreOutput score(const RescoreInput& input, const PercolatorModel& model);
 
    RescoreOutput score(const RescoreInput& input, const PercolatorModel& model, const RescoreInput& reference);
 
    static void fillPINCompatibleFields(
        const std::vector<PeptideIdentification>& peptide_ids,
        bool flatten_hits,
        RescoreInput& input);
 
    static void saveModel(const PercolatorModel& model, const std::string& filename);
 
    static PercolatorModel loadModel(const std::string& filename);
 
    std::shared_ptr<const PercolatorReset::Output> getResetOutput() const;
 
  protected:
    void updateMembers_() override;
 
  private:
    RescoreOutput rescoreReset_(const PeptideIdentificationList& peptide_ids, RescoreInput& ri,
                                const std::vector<std::pair<size_t, size_t>>& hit_locs);
    struct ReferenceScale_;
    RescoreOutput score_(const RescoreInput& input, const PercolatorModel& model, ReferenceScale_* scale);
 
    struct Impl;
    std::unique_ptr<Impl> impl_;
  };
}