AccurateMassSearchEngine.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Erhan Kenar, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/KERNEL/MassTrace.h>
#include <OpenMS/KERNEL/Feature.h>
#include <OpenMS/KERNEL/ConsensusFeature.h>
#include <OpenMS/KERNEL/FeatureMap.h>
#include <OpenMS/KERNEL/ConsensusMap.h>
#include <OpenMS/FORMAT/MzTab.h>
#include <OpenMS/FORMAT/MzTabM.h>
#include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
#include <OpenMS/DATASTRUCTURES/String.h>
#include <OpenMS/DATASTRUCTURES/ListUtils.h>
#include <OpenMS/CONCEPT/ProgressLogger.h>
#include <OpenMS/SYSTEM/File.h>
#include <OpenMS/CHEMISTRY/AdductInfo.h>
 
 
#include <iosfwd>
#include <vector>
 
namespace OpenMS
{
  class OPENMS_DLLAPI AccurateMassSearchResult
  {
  public:
    AccurateMassSearchResult();
 
    ~AccurateMassSearchResult();
 
    AccurateMassSearchResult(const AccurateMassSearchResult&);
 
    AccurateMassSearchResult& operator=(const AccurateMassSearchResult&);
 
    double getObservedMZ() const;
 
    void setObservedMZ(const double&);
 
    double getCalculatedMZ() const;
 
    void setCalculatedMZ(const double&);
 
    double getQueryMass() const;
 
    void setQueryMass(const double&);
 
    double getFoundMass() const;
 
    void setFoundMass(const double&);
 
    Int getCharge() const;
 
    void setCharge(const Int&);
 
    double getMZErrorPPM() const;
 
    void setMZErrorPPM(const double);
 
    double getObservedRT() const;
 
    void setObservedRT(const double& rt);
 
    double getObservedIntensity() const;
 
    void setObservedIntensity(const double&);
 
    std::vector<double> getIndividualIntensities() const;
 
    void setIndividualIntensities(const std::vector<double>&);
 
    Size getMatchingIndex() const;
    void setMatchingIndex(const Size&);
 
    Size getSourceFeatureIndex() const;
    void setSourceFeatureIndex(const Size&);
 
    const String& getFoundAdduct() const;
    void setFoundAdduct(const String&);
 
    const String& getFormulaString() const;
    void setEmpiricalFormula(const String&);
 
    const std::vector<String>& getMatchingHMDBids() const;
    void setMatchingHMDBids(const std::vector<String>&);
 
    const std::vector<double>& getMasstraceIntensities() const;
    void setMasstraceIntensities(const std::vector<double>&);
 
    double getIsotopesSimScore() const;
    void setIsotopesSimScore(const double&);
 
    // debug/output functions
    friend OPENMS_DLLAPI std::ostream& operator<<(std::ostream& os, const AccurateMassSearchResult& amsr);
 
private:
    double observed_mz_;
    double theoretical_mz_;
    double searched_mass_;
    double db_mass_;
    Int charge_;
    double mz_error_ppm_;
    double observed_rt_;
    double observed_intensity_;
    std::vector<double> individual_intensities_;
    Size matching_index_;
    Size source_feature_index_;
 
    String found_adduct_;
    String empirical_formula_;
    std::vector<String> matching_hmdb_ids_;
 
    std::vector<double> mass_trace_intensities_;
    double isotopes_sim_score_;
  };
 
  OPENMS_DLLAPI std::ostream& operator<<(std::ostream& os, const AccurateMassSearchResult& amsr);
 
  class OPENMS_DLLAPI AccurateMassSearchEngine :
    public DefaultParamHandler,
    public ProgressLogger
  {
public:
 
    static constexpr char search_engine_identifier[] = "AccurateMassSearchEngine";
 
    AccurateMassSearchEngine();
 
    ~AccurateMassSearchEngine() override;
 
    void queryByMZ(const double& observed_mz, const Int& observed_charge, const String& ion_mode, std::vector<AccurateMassSearchResult>& results, const EmpiricalFormula& observed_adduct = EmpiricalFormula()) const;
    void queryByFeature(const Feature& feature, const Size& feature_index, const String& ion_mode, std::vector<AccurateMassSearchResult>& results) const;
    void queryByConsensusFeature(const ConsensusFeature& cfeat, const Size& cf_index, const Size& number_of_maps, const String& ion_mode, std::vector<AccurateMassSearchResult>& results) const;
 
    void run(FeatureMap&, MzTab&) const;
 
    void run(FeatureMap&, MzTabM&) const;
 
    void run(ConsensusMap&, MzTab&) const;
 
    void init();
 
protected:
    void updateMembers_() override;
 
private:
 
    template <typename MAPTYPE> String resolveAutoMode_(const MAPTYPE& map) const
    {
      String ion_mode_internal;
      String ion_mode_detect_msg = "";
      if (map.size() > 0)
      {
        if (map[0].metaValueExists("scan_polarity"))
        {
          StringList pols = ListUtils::create<String>(String(map[0].getMetaValue("scan_polarity")), ';');
          if (pols.size() == 1 && !pols[0].empty())
          {
            pols[0].toLower();
            if (pols[0] == "positive" || pols[0] == "negative")
            {
              ion_mode_internal = pols[0];
              OPENMS_LOG_INFO << "Setting auto ion-mode to '" << ion_mode_internal << "' for file " << File::basename(map.getLoadedFilePath()) << std::endl;
            }
            else ion_mode_detect_msg = String("Meta value 'scan_polarity' does not contain unknown ion mode") + String(map[0].getMetaValue("scan_polarity"));
          }
          else
          {
            ion_mode_detect_msg = String("ambiguous ion mode: ") + String(map[0].getMetaValue("scan_polarity"));
          }
        }
        else
        {
          ion_mode_detect_msg = String("Meta value 'scan_polarity' not found in (Consensus-)Feature map");
        }
      }
      else
      { // do nothing, since map is
        OPENMS_LOG_INFO << "Meta value 'scan_polarity' cannot be determined since (Consensus-)Feature map is empty!" << std::endl;
      }
 
      if (!ion_mode_detect_msg.empty())
      {
        throw Exception::InvalidParameter(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, String("Auto ionization mode could not resolve ion mode of data (") + ion_mode_detect_msg + "!");
      }
 
      return ion_mode_internal;
    }
 
    void parseMappingFile_(const StringList&);
    void parseStructMappingFile_(const StringList&);
    void parseAdductsFile_(const String& filename, std::vector<AdductInfo>& result);
    void searchMass_(double neutral_query_mass, double diff_mass, std::pair<Size, Size>& hit_indices) const;
 
    void annotate_(const std::vector<AccurateMassSearchResult>&, BaseFeature&) const;
 
    std::vector<AccurateMassSearchResult> extractQueryResults_(const Feature& feature, const Size& feature_index, const String& ion_mode_internal, Size& dummy_count) const;
 
    void addMatchesToID_(
      IdentificationData& id,
      const std::vector<AccurateMassSearchResult>& amr, 
      const IdentificationData::InputFileRef& file_ref,
      const IdentificationData::ScoreTypeRef& mass_error_ppm_score_ref,
      const IdentificationData::ScoreTypeRef& mass_error_Da_score_ref,
      const IdentificationData::ProcessingStepRef& step_ref,
      BaseFeature& f) const;
 
    double computeCosineSim_(const std::vector<double>& x, const std::vector<double>& y) const;
 
    double computeIsotopePatternSimilarity_(const Feature& feat, const EmpiricalFormula& form) const;
 
    typedef std::vector<std::vector<AccurateMassSearchResult> > QueryResultsTable;
 
    void exportMzTab_(const QueryResultsTable& overall_results, const Size number_of_maps, MzTab& mztab_out, const std::vector<String>& file_locations) const;
 
    void exportMzTabM_(const FeatureMap& fmap, MzTabM& mztabm_out) const;
 
    typedef std::vector<std::vector<String> > MassIDMapping;
    typedef std::map<String, std::vector<String> > HMDBPropsMapping;
 
    struct MappingEntry_
    {
      double mass;
      std::vector<String> massIDs;
      String formula;
    };
    std::vector<MappingEntry_> mass_mappings_;
 
    struct CompareEntryAndMass_ // defined here to allow for inlining by compiler
    {
      double asMass(const MappingEntry_& v) const
      {
        return v.mass;
      }
 
      double asMass(double t) const
      {
        return t;
      }
 
      template <typename T1, typename T2>
      bool operator()(T1 const& t1, T2 const& t2) const
      {
        return asMass(t1) < asMass(t2);
      }
 
    };
 
    HMDBPropsMapping hmdb_properties_mapping_;
 
    bool is_initialized_; 
 
    bool legacyID_ = true;
 
    double mass_error_value_;
    String mass_error_unit_;
    String ion_mode_;
    bool iso_similarity_;
 
    String pos_adducts_fname_;
    String neg_adducts_fname_;
 
    StringList db_mapping_file_;
    StringList db_struct_file_;
 
    std::vector<AdductInfo> pos_adducts_;
    std::vector<AdductInfo> neg_adducts_;
 
    String database_name_;
    String database_version_;
    String database_location_;
 
    bool keep_unidentified_masses_;
  };
 
}