IDScoreSwitcherAlgorithm.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: Julianus Pfeuffer $
// $Authors: Julianus Pfeuffer $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
#include <OpenMS/CONCEPT/Exception.h>
#include <OpenMS/CONCEPT/LogStream.h>
#include <OpenMS/KERNEL/ConsensusMap.h>
#include <OpenMS/METADATA/PeptideIdentificationList.h>
 
#include <algorithm>
#include <vector>
#include <set>
#include <map>
 
namespace OpenMS
{
 
  class OPENMS_DLLAPI IDScoreSwitcherAlgorithm :
    public DefaultParamHandler
  {
  public:
    IDScoreSwitcherAlgorithm();
 
    enum class ScoreType
    {
      RAW,      
      RAW_EVAL, 
      PP,       
      PEP,      
      FDR,      
      QVAL,     
    };
 
    bool isScoreType(const String& score_name, const ScoreType& type) const
    {
      String chopped = score_name;
      if (chopped.hasSuffix("_score"))
      {
        chopped = chopped.chop(6);
      }
      const std::set<String>& possible_types = type_to_str_.at(type);
      return possible_types.find(chopped) != possible_types.end();
    }
 
    static ScoreType toScoreTypeEnum(String score_type)
    {
      if (score_type.hasSuffix("_score"))
      {
        score_type = score_type.chop(6);
      }
      score_type.toLower();     
      score_type.erase(std::remove_if(score_type.begin(), score_type.end(), 
                [](unsigned char c) { return c == '-' || c == '_' || c == ' '; }), 
                score_type.end());
 
      const std::map<String, ScoreType> s_to_type =
      {
        {"raw", ScoreType::RAW},
        {"rawevalue", ScoreType::RAW_EVAL},
        {"qvalue", ScoreType::QVAL},
        {"fdr", ScoreType::FDR},
        {"falsediscoveryrate", ScoreType::FDR},
        {"pep", ScoreType::PEP},
        {"posteriorerrorprobability", ScoreType::PEP},
        {"posteriorprobability", ScoreType::PP},
        {"pp", ScoreType::PP}
      };
 
      if (auto it = s_to_type.find(score_type); it != s_to_type.end())
      {
        return it->second;
      }
      else
      {
        throw Exception::MissingInformation(__FILE__, __LINE__,
                                            OPENMS_PRETTY_FUNCTION, String("Unknown score type '") + score_type + "'.");
      }
    }
 
    bool isScoreTypeHigherBetter(ScoreType score_type)
    {
      return type_to_better_[score_type];
    }
 
    std::vector<String> getScoreNames();
 
    struct ScoreSearchResult
    {
      bool is_main_score_type = false;  
      String score_name;                
    };
 
    template <typename IDType>
    ScoreSearchResult findScoreType(const IDType& id, ScoreType score_type) const
    {
      ScoreSearchResult result;
      
      // First check if main score is already of the requested score type using existing infrastructure
      const String& main_score_type = id.getScoreType();
      result.is_main_score_type = isScoreType(main_score_type, score_type);
      
      if (result.is_main_score_type)
      {
        // Main score is of the requested type, so return the main score name
        result.score_name = main_score_type;
      }
      else if (!id.getHits().empty())
      {
        // Main score is not of the requested type, look for it in meta values
        const auto& first_hit = id.getHits()[0];
        const std::set<String>& score_types = type_to_str_.at(score_type);
        
        // Search for scores of the requested type in meta values using the existing score type collection
        for (const String& score_name : score_types)
        {
          if (first_hit.metaValueExists(score_name))
          {
            result.score_name = score_name;
            break;
          }
          // Also check for "_score" suffix variant
          String score_name_with_suffix = score_name + "_score";
          if (first_hit.metaValueExists(score_name_with_suffix))
          {
            result.score_name = score_name_with_suffix;
            break;
          }
        }
      }
      // If neither main score nor meta values contain the requested type, score_name remains empty
      
      return result;
    }
 
    template <typename IDType>
    void switchScores(IDType& id, Size& counter)
    {
      for (auto hit_it = id.getHits().begin();
           hit_it != id.getHits().end(); ++hit_it, ++counter)
      {
        if (!hit_it->metaValueExists(new_score_))
        {
          std::stringstream msg;
          msg << "Meta value '" << new_score_ << "' not found for " << *hit_it;
          throw Exception::MissingInformation(__FILE__, __LINE__,
                                              OPENMS_PRETTY_FUNCTION, msg.str());
        }
 
        const String& old_score_meta = (old_score_.empty() ? id.getScoreType() :
                                 old_score_);
        const DataValue& dv = hit_it->getMetaValue(old_score_meta);
        if (!dv.isEmpty()) // meta value for old score already exists
        {
          // TODO: find a better way to check if old score type is something different (even if it has same name)
          // This currently, is a workaround for e.g., having Percolator_qvalue as meta value and same q-value as main score (getScore()).
          // Note by jpfeuffer: The problem with this is, that this may add the old score to some of the hits if different, but not
          // all, in case one is by chance the same. I would be fine with this, if it was done in the beginning and checked
          // for every score.
          if (fabs((double(dv) - hit_it->getScore()) * 2.0 /
                   (double(dv) + hit_it->getScore())) > tolerance_)
          {          
            hit_it->setMetaValue(old_score_meta + "~", hit_it->getScore());
          }
        }
        else
        {
          hit_it->setMetaValue(old_score_meta, hit_it->getScore());
        }
        hit_it->setScore(hit_it->getMetaValue(new_score_));
      }
      id.setScoreType(new_score_type_);
      id.setHigherScoreBetter(higher_better_);
    }
 
    template<class IDType>
    void switchToGeneralScoreType(std::vector<IDType>& id, ScoreType type, Size& counter)
    {
      if (id.empty()) return;
 
      auto sr = findScoreType(id[0], type);
 
      // If the main score is already of the requested type, assume all are set correctly
      if (sr.is_main_score_type)
      {
        // we assume that all the other peptide ids
        // also already have the correct score set
        return;
      }
 
      // Otherwise we need a score name to switch to
      if (sr.score_name.empty())
      {
        String msg = "First encountered ID does not have the requested score type.";
        throw Exception::MissingInformation(__FILE__, __LINE__,
                                            OPENMS_PRETTY_FUNCTION, msg);
      }
 
      String t = sr.score_name;
 
      if (t.hasSuffix("_score"))
      {
        new_score_type_ = t.chop(6);
      }
      else
      {
        new_score_type_ = t;
      }
      new_score_ = t;
 
      if (higher_better_ != type_to_better_[type])
      {
        OPENMS_LOG_WARN << "Requested score type does not match the expected score direction. Correcting!\n";
        higher_better_ = type_to_better_[type];
      }
      for (auto& i : id)
      {
        switchScores(i, counter);
      }
    }
 
    void switchToGeneralScoreType(PeptideIdentificationList& pep_ids, ScoreType type, Size& counter)
    {
      std::vector<PeptideIdentification>& vec = pep_ids.getData();
      switchToGeneralScoreType(vec, type, counter);
    }
 
    void switchToGeneralScoreType(ConsensusMap& cmap, ScoreType type, Size& counter, bool unassigned_peptides_too = true)
    {
      String new_type = "";
      for (const auto& f : cmap)
      {
        const auto& ids = f.getPeptideIdentifications();
        if (!ids.empty())
        {
          auto sr = findScoreType(ids[0], type);
          if (sr.is_main_score_type)
          {
            return;
          }
          if (!sr.score_name.empty())
          {
            new_type = sr.score_name;
            break;
          }
        }
      }
 
      if (new_type.empty())
      {
        String msg = "First encountered ID does not have the requested score type.";
        throw Exception::MissingInformation(__FILE__, __LINE__,
                                            OPENMS_PRETTY_FUNCTION, msg);
      }
 
      if (new_type.hasSuffix("_score"))
      {
        new_score_type_ = new_type.chop(6);
      }
      else
      {
        new_score_type_ = new_type;
      }
      new_score_ = new_type;
 
      if (higher_better_ != type_to_better_[type])
      {
        OPENMS_LOG_WARN << "Requested score type does not match the expected score direction. Correcting!\n";
        higher_better_ = type_to_better_[type];
      }
 
      const auto switchScoresSingle = [&counter,this](PeptideIdentification& id){switchScores(id,counter);};
      cmap.applyFunctionOnPeptideIDs(switchScoresSingle, unassigned_peptides_too);
    }
 
  void determineScoreNameOrientationAndType(
    const PeptideIdentificationList& pep_ids, 
    String& name, 
    bool& higher_better,
    ScoreType& score_type)
  {
    //TODO check all pep IDs? this assumes equality
    if (!pep_ids.empty())
    {
      name = pep_ids[0].getScoreType(); // The name of the score. Typically a name like "XTandem" or "Percolator_qvalue"
      higher_better = pep_ids[0].isHigherScoreBetter();
      
      // look up the score category ("RAW", "PEP", "q-value", etc.) for the given score name
      for (auto& [scoretype, names] : type_to_str_)
      {
        if (names.find(name) != names.end())
        {
          score_type = scoretype;
          OPENMS_LOG_INFO << "Found score type " << name << " to be of type " 
            << static_cast<std::underlying_type<ScoreType>::type>(scoretype) << std::endl;
          return;
        }
      }
    }
  }
 
  void determineScoreNameOrientationAndType(const ConsensusMap& cmap, 
    String& name,
    bool& higher_better,
    ScoreType& score_type,
    bool include_unassigned = true)
  {
    name = "";
    higher_better = true;
 
    // TODO: check all pep IDs? this assumes equality to first encountered
    for (const auto& cf : cmap)
    {
      const auto& pep_ids = cf.getPeptideIdentifications();
      if (!pep_ids.empty())
      {
        name = pep_ids[0].getScoreType();
        higher_better = pep_ids[0].isHigherScoreBetter();
 
        // look up the score category ("RAW", "PEP", "q-value", etc.) for the given score name
        for (auto& [scoretype, names] : type_to_str_)
        {
          if (names.find(name) != names.end())
          {
            score_type = scoretype;
            return;
          }
        }
      }
    }
 
    if (name.empty() && include_unassigned)
    {
      for (const auto& id : cmap.getUnassignedPeptideIdentifications())
      {
        name = id.getScoreType();
        higher_better = id.isHigherScoreBetter();
 
         // look up the score category ("RAW", "PEP", "q-value", etc.) for the given score name
        for (auto& [scoretype, names] : type_to_str_)
        {
          if (names.find(name) != names.end())
          {
            score_type = scoretype;
            return;
          }
        }        
        return;
      }
    }    
  }
 
    void switchScores(ConsensusMap& cmap, Size& counter, bool unassigned_peptides_too = true)
    {
      for (const auto& f : cmap)
      {
        const auto& ids = f.getPeptideIdentifications();
        if (!ids.empty())
        {
          if (new_score_ == ids[0].getScoreType()) // correct score or category already set
          {
            return;
          }
          else
          {
            break;
          }
        }
      }      
      const auto switchScoresSingle = [&counter,this](PeptideIdentification& id){switchScores(id,counter);};
      cmap.applyFunctionOnPeptideIDs(switchScoresSingle, unassigned_peptides_too);
    }
    
    void switchScores(PeptideIdentificationList& pep_ids, Size& counter)
    {
      if (pep_ids.empty()) return;
 
      if (new_score_ == pep_ids[0].getScoreType()) // correct score already set
      {
        return;
      }
      
      for (auto& id : pep_ids)
      {
        switchScores(id, counter);
      }
    }
 
 
  struct IDSwitchResult
  {
    // the score name, orientation and type used before the switch
    String original_score_name; 
    bool original_score_higher_better = true; 
    IDScoreSwitcherAlgorithm::ScoreType original_score_type = IDScoreSwitcherAlgorithm::ScoreType::RAW; 
    // the score name, orientation and type used after the switch
    bool requested_score_higher_better = original_score_higher_better; 
    IDScoreSwitcherAlgorithm::ScoreType requested_score_type = original_score_type; 
    String requested_score_name; // the search engine score name (e.g. "X!Tandem_score" or score category (e.g. "PEP")
    // wheter the main score was switched
    bool score_switched = false; 
  };
 
  static IDSwitchResult switchToScoreType(ConsensusMap& cmap, String requested_score_type_as_string, bool include_unassigned = true)
  {
    IDSwitchResult result;
    // fill in the original score name, orientation and type
    IDScoreSwitcherAlgorithm().determineScoreNameOrientationAndType(cmap, 
      result.original_score_name, 
      result.original_score_higher_better, 
      result.original_score_type,
      include_unassigned);
 
    // initalize with the assumption that the main score is the requested score
    result.requested_score_name = result.original_score_name; // the search engine score name (e.g. "X!Tandem_score" or score category (e.g. "PEP")
    result.requested_score_type = result.original_score_type;
    result.requested_score_higher_better = result.original_score_higher_better;          
 
    // no score type specified -> use main score
    if (requested_score_type_as_string.empty())
    {
      OPENMS_LOG_DEBUG << "No score type specified. Using main score." << std::endl;
      return result;
    }
 
    // ENUM for requested score type (e.g. "RAW", "PEP", "q-value")
    result.requested_score_type = IDScoreSwitcherAlgorithm::toScoreTypeEnum(requested_score_type_as_string);
    if (result.requested_score_type != result.original_score_type) // switch needed because we change type?
    { // user requests a different score type than the main score
      result.requested_score_higher_better = IDScoreSwitcherAlgorithm().isScoreTypeHigherBetter(result.requested_score_type);
      IDScoreSwitcherAlgorithm idsa;
      auto param = idsa.getDefaults();
      param.setValue("new_score", result.requested_score_name);
      param.setValue("new_score_orientation", result.requested_score_higher_better ? "higher_better" : "lower_better");
      param.setValue("proteins", "false");
      param.setValue("old_score", ""); // use default name generated for old score
      idsa.setParameters(param);            
 
      Size counter = 0; 
      idsa.switchToGeneralScoreType(cmap, result.requested_score_type, counter, include_unassigned);
      OPENMS_LOG_DEBUG << "Switched scores for " << counter << " IDs." << std::endl;
      result.score_switched = true;
    }
 
    // update after potential switch and read out actual score name
    IDScoreSwitcherAlgorithm().determineScoreNameOrientationAndType(cmap, 
      result.requested_score_name, 
      result.requested_score_higher_better, 
      result.requested_score_type,
      include_unassigned);
 
    return result;
  }
 
  static IDSwitchResult switchToScoreType(PeptideIdentificationList& pep_ids, String requested_score_type_as_string)
  {
    IDSwitchResult result;
    // fill in the original score name, orientation and type
    IDScoreSwitcherAlgorithm().determineScoreNameOrientationAndType(pep_ids, 
      result.original_score_name, 
      result.original_score_higher_better, 
      result.original_score_type
      );
 
    // initalize with the assumption that the main score is the requested score
    result.requested_score_name = result.original_score_name; // the search engine score name (e.g. "X!Tandem_score" or score category (e.g. "PEP")
    result.requested_score_type = result.original_score_type;
    result.requested_score_higher_better = result.original_score_higher_better;
 
    // no score type specified -> use main score
    if (requested_score_type_as_string.empty())
    {
      OPENMS_LOG_DEBUG << "No score type specified. Using main score." << std::endl;
      return result;
    }
 
    // ENUM for requested score type (e.g. "RAW", "PEP", "q-value")
    result.requested_score_type = IDScoreSwitcherAlgorithm::toScoreTypeEnum(requested_score_type_as_string);
    if (result.requested_score_type != result.original_score_type) // switch needed because we change type?
    { // user requests a different score type than the main score
      result.requested_score_higher_better = IDScoreSwitcherAlgorithm().isScoreTypeHigherBetter(result.requested_score_type);
      IDScoreSwitcherAlgorithm idsa;
      auto param = idsa.getDefaults();
      param.setValue("new_score", result.requested_score_name);
      param.setValue("new_score_orientation", result.requested_score_higher_better ? "higher_better" : "lower_better");
      param.setValue("proteins", "false");
      param.setValue("old_score", ""); // use default name generated for old score
      idsa.setParameters(param);            
      Size counter = 0;       
      idsa.switchToGeneralScoreType(pep_ids, result.requested_score_type, counter);
      OPENMS_LOG_DEBUG << "Switched scores for " << counter << " IDs." << std::endl;
 
      result.score_switched = true;
    }
 
    // update after potential switch and read out actual score name
    IDScoreSwitcherAlgorithm().determineScoreNameOrientationAndType(pep_ids, 
      result.requested_score_name, 
      result.requested_score_higher_better, 
      result.requested_score_type
      );
 
    return result;
  }
 
  static void switchBackScoreType(ConsensusMap& cmap, IDSwitchResult isr, bool include_unassigned = true)
  {
    if (isr.score_switched)
    {
      // switch back to original score
      IDScoreSwitcherAlgorithm idsa;
      auto param = idsa.getDefaults();
      param.setValue("new_score", isr.original_score_name);
      param.setValue("new_score_orientation", isr.original_score_higher_better ? "higher_better" : "lower_better");
      param.setValue("proteins", "false");
      param.setValue("old_score", ""); // use default name generated for old score
      idsa.setParameters(param);
      Size counter = 0;
      idsa.switchScores(cmap, counter, include_unassigned);
      OPENMS_LOG_DEBUG << "Switched scores back for " << counter << " PSMs." << std::endl;
    }
  }
 
  static void switchBackScoreType(PeptideIdentificationList& pep_ids, IDSwitchResult isr)
  {
    if (isr.score_switched)
    {
      // switch back to original score
      IDScoreSwitcherAlgorithm idsa;
      auto param = idsa.getDefaults();
      param.setValue("new_score", isr.original_score_name);
      param.setValue("new_score_orientation", isr.original_score_higher_better ? "higher_better" : "lower_better");
      param.setValue("proteins", "false");
      param.setValue("old_score", ""); // use default name generated for old score
      idsa.setParameters(param);
      Size counter = 0;
      idsa.switchScores(pep_ids, counter);
      OPENMS_LOG_DEBUG << "Switched scores back for " << counter << " PSMs." << std::endl;
    }
  }
 
  private:
 
    void updateMembers_() override; 
 
    const double tolerance_ = 1e-6;
 
    String new_score_, new_score_type_, old_score_;
 
    bool higher_better_; // for the new scores, are higher ones better?
 
    std::map<ScoreType, std::set<String>> type_to_str_ =
        {
            //TODO introduce real meaningful score names for XTandem, Mascot etc. (e.g., hyperscore)
            {ScoreType::RAW, {"svm", "MS:1001492", "XTandem", "OMSSA", "SEQUEST:xcorr", "Mascot", "mvh", "hyperscore", "ln(hyperscore)"}},
            //TODO find out reasonable raw scores for SES that provide E-Values as main score or see below
            //TODO there is no test for spectraST idXML, so I don't know its score
            //TODO check if we should combine RAW and RAW_EVAL:
            // What if a SE does not have an e-value score (spectrast, OMSSA, crux/sequest, myrimatch),
            // then you need additional if's/try's
            {ScoreType::RAW_EVAL, {"expect", "SpecEValue", "E-Value", "evalue", "MS:1002053", "MS:1002257"}},
            {ScoreType::PP, {"Posterior Probability"}},
            {ScoreType::PEP, {"Posterior Error Probability", "pep", "PEP", "posterior_error_probability", "MS:1001493"}}, // TODO add CV terms
            {ScoreType::FDR, {"FDR", "fdr", "false discovery rate"}},
            {ScoreType::QVAL, {"q-value", "qvalue", "MS:1001491", "q-Value", "qval"}}
        };
 
    std::map<ScoreType, bool> type_to_better_ =
        {
            {ScoreType::RAW, true}, //TODO this might actually not always be true
            {ScoreType::RAW_EVAL, false},
            {ScoreType::PP, true},
            {ScoreType::PEP, false},
            {ScoreType::FDR, false},
            {ScoreType::QVAL, false}
        };        
  };
} // namespace OpenMS