FalseDiscoveryRate.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2018.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $Maintainer: Chris Bielow $
// $Authors: Andreas Bertsch, Chris Bielow $
// --------------------------------------------------------------------------

#pragma once

#include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
#include <OpenMS/METADATA/PeptideIdentification.h>
#include <OpenMS/METADATA/ProteinIdentification.h>

#include <vector>
#include <unordered_set>

namespace OpenMS
{
  class OPENMS_DLLAPI FalseDiscoveryRate :
    public DefaultParamHandler
  {
public:
    FalseDiscoveryRate();

    void apply(std::vector<PeptideIdentification> & fwd_ids, std::vector<PeptideIdentification> & rev_ids) const;

    void apply(std::vector<PeptideIdentification> & id) const;

    void apply(std::vector<ProteinIdentification>& fwd_ids, std::vector<ProteinIdentification>& rev_ids) const;

    void apply(std::vector<ProteinIdentification>& ids) const;

    void applyEstimated(std::vector<ProteinIdentification>& ids) const;

    double applyEvaluateProteinIDs(const std::vector<ProteinIdentification>& ids, double pepCutoff = 1.0, UInt fpCutoff = 50, double diffWeight = 0.2);
    double applyEvaluateProteinIDs(const ProteinIdentification& ids, double pepCutoff = 1.0, UInt fpCutoff = 50, double diffWeight = 0.2);

    void applyBasic(std::vector<PeptideIdentification> & ids);
    void applyBasic(ProteinIdentification & id, bool groups_too = true);

    double rocN(const std::vector<PeptideIdentification>& ids, Size fp_cutoff) const;


private:

    FalseDiscoveryRate(const FalseDiscoveryRate &);

    FalseDiscoveryRate & operator=(const FalseDiscoveryRate &);

    //TODO we could add identifier here. If we need to combine runs.
    void getScores_(
      std::vector<std::pair<double,bool>>& scores_labels, 
      const ProteinIdentification & id) const;

    void getScores_(
        std::vector<std::pair<double,bool>>& scores_labels,
        const std::vector<ProteinIdentification::ProteinGroup> & grps,
        const std::unordered_set<std::string> & decoy_accs) const;

    void getScores_(
      std::vector<std::pair<double,bool>>& scores_labels, 
      const std::vector<PeptideIdentification> & ids, 
      bool all_hits, 
      int charge, String identifier) const;

    void getScores_(
      std::vector<std::pair<double,bool>>& scores_labels, 
      const std::vector<PeptideIdentification> & targets, 
      const std::vector<PeptideIdentification> & decoys, 
      bool all_hits, 
      int charge, 
      const String& identifier) const;

    void setScores_(
      const std::map<double,double>& scores_to_FDR, 
      std::vector<PeptideIdentification> & id, 
      const std::string& score_type, 
      bool higher_better) const;

    template <typename IDType>
    void setScores_(const std::map<double,double>& scores_to_FDR, IDType & id, const std::string& score_type, bool higher_better) const
    {
      String old_score_type = id.getScoreType() + "_score";
      id.setScoreType(score_type);
      id.setHigherScoreBetter(higher_better);
      for (auto& hit : id.getHits())
      {
        double old_score = hit.getScore();
        hit.setScore(scores_to_FDR.lower_bound(hit.getScore())->second);
        hit.setMetaValue(old_score_type, old_score);
      }
    }

    void setScores_(
        const std::map<double,double>& scores_to_FDR,
        std::vector<ProteinIdentification::ProteinGroup>& grps,
        const std::string& score_type,
        bool higher_better) const;

    template <typename IDType>
    void checkTDAnnotation_ (const IDType & id) const
    {
      for (auto const& hit : id.getHits())
      {
        if (!hit.metaValueExists("target_decoy"))
        {
          throw Exception::MissingInformation(__FILE__,
                                              __LINE__,
                                              OPENMS_PRETTY_FUNCTION,
                                              "Meta value 'target_decoy' does not exist in all ProteinHits! Reindex the idXML file with 'PeptideIndexer'");
        }
      }
    }

    template <typename HitType>
    struct GetLabelFunctor: std::function<bool(const HitType&)>
    {
      bool operator() (const HitType& hit)
      {
        //TODO if we checked in the beginning, this check could be skipped.
        if (!hit.metaValueExists("target_decoy"))
        {
          throw Exception::MissingInformation(__FILE__,
                                              __LINE__,
                                              OPENMS_PRETTY_FUNCTION,
                                              "Meta value 'target_decoy' does not exist in all ProteinHits! Reindex the idXML file with 'PeptideIndexer'");
        }
        else
        {
          return std::string(hit.getMetaValue("target_decoy"))[0] == 't';
        }
      }
    };

    template <typename HitType>
    struct TrueFunctor: std::function<bool(const HitType&)>
    {
      bool operator() (const HitType& /*hit*/)
      {
        return true;
      }
    };

    template <typename HitType>
    struct FalseFunctor: std::function<bool(const HitType&)>
    {
      bool operator() (const HitType& /*hit*/)
      {
        return false;
      }
    };


    template <typename HitType>
    std::pair<double,bool> getScoreLabel_(const HitType& hit, std::function<bool(const HitType&)> fun) const
    {
      return std::make_pair(hit.getScore(), fun(hit));
    }

    void calculateFDRs_(Map<double, double>& score_to_fdr, std::vector<double>& target_scores, std::vector<double>& decoy_scores, bool q_value, bool higher_score_better) const;

    void calculateEstimatedQVal_(std::map<double, double> &scores_to_FDR,
                                 std::vector<std::pair<double, bool>> &scores_labels,
                                 bool higher_score_better) const;

    void calculateFDRBasic_(std::map<double,double>& scores_to_FDR, std::vector<std::pair<double,bool>>& scores_labels, bool qvalue, bool higher_score_better);

    //TODO the next two methods could potentially be merged for speed (they iterate over the same structure)
    //But since they have different cutoff types and it is more generic, I leave it like this.
    double diffEstimatedEmpirical_(const std::vector<std::pair<double, bool>>& scores_labels, double pepCutoff = 1.0);

    double rocN_(std::vector<std::pair<double, bool>> const &scores_labels, Size fpCutoff = 50) const;

    double trapezoidal_area_xEqy(double exp1, double exp2, double act1, double act2) const;

    double trapezoidal_area(double x1, double x2, double y1, double y2) const;


  };

} // namespace OpenMS