FFIDAlgoExternalIDHandler.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: Hendrik Weisser $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/ANALYSIS/MAPMATCHING/TransformationDescription.h>
#include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
#include <OpenMS/DATASTRUCTURES/ListUtils.h>
#include <OpenMS/KERNEL/Feature.h>
#include <OpenMS/KERNEL/FeatureMap.h>
#include <OpenMS/CHEMISTRY/AASequence.h>
#include <OpenMS/METADATA/PeptideIdentification.h>
#include <OpenMS/METADATA/ProteinIdentification.h>
#include <OpenMS/CONCEPT/Exception.h>
#include <OpenMS/CONCEPT/Types.h>
 
#include <map>
#include <set>
#include <vector>
 
namespace OpenMS
{
namespace Internal
{
  class OPENMS_DLLAPI FFIDAlgoExternalIDHandler
  {
  public:
    typedef std::multimap<double, PeptideIdentification*> ExternalRTMap;
    
    typedef std::map<Int, ExternalRTMap> ExternalChargeMap;
    
    typedef std::map<AASequence, ExternalChargeMap> ExternalPeptideMap;
 
    FFIDAlgoExternalIDHandler();
 
    void reset();
 
    void addExternalPeptide(PeptideIdentification& peptide);
    
    void processExternalPeptides(std::vector<PeptideIdentification>& peptides_ext);
    
    double alignInternalAndExternalIDs(
        const std::vector<PeptideIdentification>& peptides_internal,
        const std::vector<PeptideIdentification>& peptides_external,
        double rt_quantile);
    
    double transformRT(double rt) const;
    
    bool hasRTTransformation() const;
    
    const TransformationDescription& getRTTransformation() const;
        
    void classifyFeaturesWithSVM(FeatureMap& features, const Param& param);
 
    void filterClassifiedFeatures(FeatureMap& features, double quality_cutoff);
 
    void calculateFDR(FeatureMap& features);
    
    const std::map<double, std::pair<Size, Size> >& getSVMProbsInternal() const;
     
  private:
    void addExternalPeptideToMap_(PeptideIdentification& peptide,
                               std::map<AASequence,
                               std::map<Int, std::pair<std::multimap<double, PeptideIdentification*>,
                                                      std::multimap<double, PeptideIdentification*>>>>& peptide_map);
    
    bool fillExternalRTMap_(const AASequence& sequence, Int charge,
                         std::multimap<double, PeptideIdentification*>& rt_map);
    
    void annotateFeatureWithExternalIDs_(Feature& feature);
  
    void initSVMParameters_(const Param& param);
 
    void finalizeAssayFeatures_(Feature& best_feature, double best_quality, double quality_cutoff);
 
    void getRandomSample_(std::map<Size, double>& training_labels);
 
    void checkNumObservations_(Size n_pos, Size n_neg, const String& note = "") const;
 
    void getUnbiasedSample_(const std::multimap<double, std::pair<Size, bool> >& valid_obs,
                          std::map<Size, double>& training_labels);
 
    void addDummyPeptideID_(Feature& feature, const PeptideIdentification* ext_id);
    
    void handleExternalFeature_(Feature& feature, double prob_positive, double quality_cutoff);
    
    void adjustFDRForExternalFeatures_(std::vector<double>& fdr_probs,
                                    std::vector<double>& fdr_qvalues,
                                    Size n_internal_features);
 
    ExternalPeptideMap external_peptide_map_;
    
    TransformationDescription rt_transformation_;
    
    Size n_external_peptides_;
    
    Size n_external_features_;
    
    std::multiset<double> svm_probs_external_;
 
    std::map<double, std::pair<Size, Size> > svm_probs_internal_;
    
    Size svm_n_parts_;
    
    Size svm_n_samples_;
    
    double svm_min_prob_;
 
    double svm_quality_cutoff;
 
    std::vector<String> svm_predictor_names_;
 
    String svm_xval_out_;
 
    Int debug_level_;
 
    Size n_internal_features_;
  };
 
} // namespace Internal
} // namespace OpenMS