TargetedSpectraExtractor.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: Douglas McCloskey, Pasquale Domenico Colaianni $
// $Authors: Douglas McCloskey, Pasquale Domenico Colaianni $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/config.h> // OPENMS_DLLAPI
#include <OpenMS/ANALYSIS/TARGETED/TargetedExperiment.h>
#include <OpenMS/COMPARISON/BinnedSpectralContrastAngle.h>
#include <OpenMS/KERNEL/BinnedSpectrum.h>
#include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/KERNEL/FeatureMap.h>
 
namespace OpenMS
{
  class OPENMS_DLLAPI TargetedSpectraExtractor :
    public DefaultParamHandler
  {
public:
    TargetedSpectraExtractor();
    ~TargetedSpectraExtractor() override = default;
 
    struct Match
    {
      Match() = default;
      Match(MSSpectrum a, double b) : spectrum(std::move(a)), score(b) {}
      MSSpectrum spectrum;
      double score = 0.0;
    };
 
    class OPENMS_DLLAPI Comparator
    {
    public:
      virtual ~Comparator() = default;
      virtual void generateScores(
        const MSSpectrum& spec,
        std::vector<std::pair<Size,double>>& scores,
        double min_score
      ) const = 0;
 
      virtual void init(
        const std::vector<MSSpectrum>& library,
        const std::map<std::string,DataValue>& options
      ) = 0;
 
      const std::vector<MSSpectrum>& getLibrary() const
      {
        return library_;
      }
 
    protected:
      std::vector<MSSpectrum> library_;
    };
 
    class OPENMS_DLLAPI BinnedSpectrumComparator : public Comparator
    {
    public:
      ~BinnedSpectrumComparator() override = default;
      void generateScores (
        const MSSpectrum& spec,
        std::vector<std::pair<Size,double>>& scores,
        double min_score
      ) const override
      {
        scores.clear();
        const BinnedSpectrum in_bs(spec, bin_size_, false, peak_spread_, bin_offset_);
        for (Size i = 0; i < bs_library_.size(); ++i)
        {
          const double cmp_score = cmp_bs_(in_bs, bs_library_[i]);
          if (cmp_score >= min_score)
          {
            scores.emplace_back(i, cmp_score);
          }
        }
      }
 
      void init(const std::vector<MSSpectrum>& library, const std::map<std::string,DataValue>& options) override;
 
    private:
      BinnedSpectralContrastAngle cmp_bs_;
      std::vector<BinnedSpectrum> bs_library_;
      double bin_size_ = 0.02; // Default for nominal mass: 1.0;
      UInt peak_spread_ = 0;
      double bin_offset_ = 0.0; // Default for nominal mass resolution: 0.4;
    };
 
    void getDefaultParameters(Param& params) const;
 
    void annotateSpectra(
      const std::vector<MSSpectrum>& spectra,
      const TargetedExperiment& targeted_exp,
      std::vector<MSSpectrum>& annotated_spectra,
      FeatureMap& features,
      bool compute_features = true
    ) const;
 
    void annotateSpectra(
      const std::vector<MSSpectrum>& spectra,
      const TargetedExperiment& targeted_exp,
      std::vector<MSSpectrum>& annotated_spectra
    ) const;
 
    void annotateSpectra(
        const std::vector<MSSpectrum>& spectra,
        const FeatureMap& ms1_features,
        FeatureMap& ms2_features,
        std::vector<MSSpectrum>& annotated_spectra) const;
    
    void searchSpectrum(
        OpenMS::FeatureMap& feat_map,
        OpenMS::FeatureMap& feat_map_output,
        bool add_unidentified_features = false) const;
 
    void pickSpectrum(const MSSpectrum& spectrum, MSSpectrum& picked_spectrum) const;
 
    void scoreSpectra(
      const std::vector<MSSpectrum>& annotated_spectra,
      const std::vector<MSSpectrum>& picked_spectra,
      FeatureMap& features,
      std::vector<MSSpectrum>& scored_spectra,
      bool compute_features = true
    ) const;
 
    void scoreSpectra(
      const std::vector<MSSpectrum>& annotated_spectra,
      const std::vector<MSSpectrum>& picked_spectra,
      std::vector<MSSpectrum>& scored_spectra
    ) const;
 
    void selectSpectra(
      const std::vector<MSSpectrum>& scored_spectra,
      const FeatureMap& features,
      std::vector<MSSpectrum>& selected_spectra,
      FeatureMap& selected_features,
      bool compute_features = true
    ) const;
 
    void selectSpectra(
      const std::vector<MSSpectrum>& scored_spectra,
      std::vector<MSSpectrum>& selected_spectra
    ) const;
 
    void extractSpectra(
      const MSExperiment& experiment,
      const TargetedExperiment& targeted_exp,
      std::vector<MSSpectrum>& extracted_spectra,
      FeatureMap& extracted_features,
      bool compute_features = true
    ) const;
 
    void extractSpectra(
      const MSExperiment& experiment,
      const TargetedExperiment& targeted_exp,
      std::vector<MSSpectrum>& extracted_spectra
    ) const;
    
    void extractSpectra(
      const MSExperiment& experiment,
      const FeatureMap& ms1_features,
      std::vector<MSSpectrum>& extracted_spectra
    ) const;
    
    void extractSpectra(
      const MSExperiment& experiment,
      const FeatureMap& ms1_features,
      std::vector<MSSpectrum>& extracted_spectra,
      FeatureMap& extracted_features
    ) const; 
    
    void matchSpectrum(
      const MSSpectrum& input_spectrum,
      const Comparator& cmp,
      std::vector<Match>& matches
    ) const;
 
    void targetedMatching(
      const std::vector<MSSpectrum>& spectra,
      const Comparator& cmp,
      FeatureMap& features
    );
 
    void untargetedMatching(
      const std::vector<MSSpectrum>& spectra,
      const Comparator& cmp,
      FeatureMap& features
    );
 
    void constructTransitionsList(const OpenMS::FeatureMap& ms1_features, const OpenMS::FeatureMap& ms2_features, TargetedExperiment& t_exp) const;
 
    void storeSpectraMSP(const std::string& filename, MSExperiment& experiment) const;
    
    void mergeFeatures(const OpenMS::FeatureMap& fmap_input, OpenMS::FeatureMap& fmap_output) const;
 
protected:
    void updateMembers_() override;
 
    void deisotopeMS2Spectra_(MSExperiment& experiment) const;
 
    void removeMS2SpectraPeaks_(MSExperiment& experiment) const;
 
    void organizeMapWithSameIdentifier(const OpenMS::FeatureMap& fmap_input, std::map<std::string, std::vector<OpenMS::Feature>>& fmapmap) const;
 
  private:
    void extractSpectra(
      const MSExperiment& experiment,
      const FeatureMap& ms1_features,
      std::vector<MSSpectrum>& extracted_spectra,
      FeatureMap& extracted_features,
      const bool compute_features
    ) const;
 
  private:
    bool mz_unit_is_Da_;
 
    double rt_window_;
 
    double mz_tolerance_;
 
    double peak_height_min_;
 
    double peak_height_max_;
 
    double fwhm_threshold_;
 
    double tic_weight_; 
    double fwhm_weight_; 
    double snr_weight_; 
    double min_select_score_;
 
    bool use_gauss_;
 
    Size top_matches_to_report_;
 
    double min_match_score_;
 
    double min_fragment_mz_;
    double max_fragment_mz_;
 
    double relative_allowable_product_mass_;
 
    bool deisotoping_use_deisotoper_;
    double deisotoping_fragment_tolerance_;
    std::string deisotoping_fragment_unit_;
    int deisotoping_min_charge_;
    int deisotoping_max_charge_;
    int deisotoping_min_isopeaks_;
    int deisotoping_max_isopeaks_;
    bool deisotoping_keep_only_deisotoped_;
    bool deisotoping_annotate_charge_;
 
    double max_precursor_mass_threashold_;
  };
}