FLASHDeconvAlgorithm.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: Kyowon Jeong, Jihyung Kim $
// $Authors: Kyowon Jeong, Jihyung Kim $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/ANALYSIS/TOPDOWN/DeconvolvedSpectrum.h>
#include <OpenMS/ANALYSIS/TOPDOWN/FLASHHelperClasses.h>
#include <OpenMS/ANALYSIS/TOPDOWN/PeakGroup.h>
#include <OpenMS/ANALYSIS/TOPDOWN/SpectralDeconvolution.h>
#include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
#include <OpenMS/DATASTRUCTURES/Matrix.h>
#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/KERNEL/MSSpectrum.h>
#include <boost/dynamic_bitset.hpp>
#include <iostream>
 
namespace OpenMS
{
  class OPENMS_DLLAPI FLASHDeconvAlgorithm : public DefaultParamHandler, public ProgressLogger
  {
  public:
    FLASHDeconvAlgorithm();
 
    FLASHDeconvAlgorithm(const FLASHDeconvAlgorithm&) = default;
 
    FLASHDeconvAlgorithm(FLASHDeconvAlgorithm&& other)  noexcept = default;
 
    FLASHDeconvAlgorithm& operator=(const FLASHDeconvAlgorithm& fd) = default;
 
    FLASHDeconvAlgorithm& operator=(FLASHDeconvAlgorithm&& fd) = default;
 
    ~FLASHDeconvAlgorithm() override = default;
 
    std::vector<double> getTolerances() const;
 
    void run(MSExperiment& map, std::vector<DeconvolvedSpectrum>& deconvolved_spectra, std::vector<FLASHHelperClasses::MassFeature>& deconvolved_feature);
 
    const FLASHHelperClasses::PrecalculatedAveragine& getAveragine();
 
    const FLASHHelperClasses::PrecalculatedAveragine& getDecoyAveragine();
 
    double getNoiseDecoyWeight() const
    {
      return noise_decoy_weight_;
    }
    static int getScanNumber(const MSExperiment& map, Size index);
 
  protected:
    void updateMembers_() override;
 
  private:
    SpectralDeconvolution sd_, sd_noise_decoy_, sd_signal_decoy_;
 
    int merge_spec_ = 0;
 
    int forced_ms_level_ = 0;
 
    UInt max_ms_level_ = 4;
 
    UInt current_max_ms_level_ = 0;
 
    UInt current_min_ms_level_ = 0;
 
    int precursor_MS1_window_ = 0;
 
    String ida_log_file_;
 
    DoubleList tols_, min_cos_;
 
    bool use_RNA_averagine_ = false;
 
    bool report_decoy_ = false;
 
    double isolation_window_size_{3.0};
 
    double noise_decoy_weight_ = 1;
    std::map<int, std::vector<std::vector<float>>> precursor_map_for_ida_;
    std::map<String, PeakGroup> native_id_precursor_peak_group_map_;
 
    void updateMSLevels_(MSExperiment& map);
 
    void mergeSpectra_(MSExperiment& map, uint ms_level);
 
    void runSpectralDeconvolution_(MSExperiment& map, std::vector<DeconvolvedSpectrum>& deconvolved_spectra);
 
    int findPrecursorScanNumber_(const MSExperiment& map, Size index, uint ms_level) const;
 
    void appendDecoyPeakGroups_(DeconvolvedSpectrum& deconvolved_spectrum, const MSSpectrum& spec, int scan_number, const PeakGroup& precursor_pg);
 
    void runFeatureFinding_(std::vector<DeconvolvedSpectrum>& deconvolved_spectra, std::vector<FLASHHelperClasses::MassFeature>& deconvolved_features);
 
    static void updatePrecursorQScores_(std::vector<DeconvolvedSpectrum>& deconvolved_spectra, int ms_level);
 
    void findPrecursorPeakGroupsFormIdaLog_(const MSExperiment& map, Size index, double start_mz, double end_mz);
 
    void findPrecursorPeakGroupsForMSnSpectra_(const MSExperiment& map, const std::vector<DeconvolvedSpectrum>& deconvolved_spectra, uint ms_level);
 
    std::pair<int, int> findScanNumberBounds_(const MSExperiment& map, Size index, uint ms_level) const;
 
    std::vector<DeconvolvedSpectrum> collectSurveyScans_(const std::vector<DeconvolvedSpectrum>& deconvolved_spectra, int b_scan_number, int a_scan_number, uint ms_level) const;
 
    std::pair<double, double> getIsolationWindowMzRange_(const MSSpectrum& spec) const;
 
    PeakGroup findBestPrecursorPeakGroup_(const std::vector<DeconvolvedSpectrum>& survey_scans, double start_mz, double end_mz) const;
 
    void determineTolerance_(const MSExperiment& map, const Param& sd_param, const FLASHHelperClasses::PrecalculatedAveragine& avg, uint ms_level);
 
    static std::vector<int> getHistogram_(const std::vector<double>& data, double min_range, double max_range, double bin_size);
 
    static void filterLowPeaks_(MSExperiment& map);
  };
} // namespace OpenMS