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-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: 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();
    virtual ~TargetedSpectraExtractor() = default;

    struct Match
    {
      Match() = default;
      Match(MSSpectrum a, double b) : spectrum(a), score(b) {}
      MSSpectrum spectrum;
      double score;
    };

    class Comparator
    {
    public:
      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 BinnedSpectrumComparator : public Comparator
    {
    public:
      void generateScores(
        const MSSpectrum& spec,
        std::vector<std::pair<Size,double>>& scores,
        double min_score
      ) const
      {
        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)
      {
        if (options.count("bin_size"))
        {
          bin_size_ = options.at("bin_size");
        }
        if (options.count("peak_spread"))
        {
          peak_spread_ = options.at("peak_spread");
        }
        if (options.count("bin_offset"))
        {
          bin_offset_ = options.at("bin_offset");
        }
        library_ = library;
        bs_library_.clear();
        for (const MSSpectrum& s : library_)
        {
          bs_library_.emplace_back(s, bin_size_, false, peak_spread_, bin_offset_);
        }
        LOG_INFO << "The library contains " << bs_library_.size() << " spectra." << std::endl;
      }
    private:
      BinnedSpectralContrastAngle cmp_bs_;
      std::vector<BinnedSpectrum> bs_library_;
      double bin_size_ = 1.0;
      double peak_spread_ = 0.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,
      const bool compute_features = true
    ) const;

    void annotateSpectra(
      const std::vector<MSSpectrum>& spectra,
      const TargetedExperiment& targeted_exp,
      std::vector<MSSpectrum>& annotated_spectra
    ) 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,
      const 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,
      const 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,
      const 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
    );

    void targetedMatching(
      const std::vector<MSSpectrum>& spectra,
      const Comparator& cmp,
      FeatureMap& features
    );

    void untargetedMatching(
      const std::vector<MSSpectrum>& spectra,
      const Comparator& cmp,
      FeatureMap& features
    );

protected:
    void updateMembers_();

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_;
  };
}