TargetedSpectraExtractor.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-2021.
//
// 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: 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/SPECTRA/BinnedSpectralContrastAngle.h>
#include <OpenMS/COMPARISON/SPECTRA/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<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<String,DataValue>& options) override;
 
    private:
      BinnedSpectralContrastAngle cmp_bs_;
      std::vector<BinnedSpectrum> bs_library_;
      double bin_size_ = 1.0;
      UInt peak_spread_ = 0;
      double bin_offset_ = 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) 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 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 storeSpectraTraML(const String& filename, const OpenMS::FeatureMap& ms1_features, const OpenMS::FeatureMap& ms2_features) const;
 
    void storeSpectraMSP(const 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:
    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_;
  };
}