IonMobilityScoring.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: Hannes Roest $
// $Authors: Hannes Roest $
// --------------------------------------------------------------------------
 
#pragma once
 
// data access
#include <OpenMS/OPENSWATHALGO/DATAACCESS/DataStructures.h>
#include <OpenMS/OPENSWATHALGO/DATAACCESS/ISpectrumAccess.h>
#include <OpenMS/OPENSWATHALGO/DATAACCESS/ITransition.h>
#include <OpenMS/OPENSWATHALGO/DATAACCESS/TransitionExperiment.h>
#include <OpenMS/OPENSWATHALGO/DATAACCESS/SwathMap.h>
#include <OpenMS/ANALYSIS/OPENSWATH/OpenSwathScoring.h>
#include <OpenMS/KERNEL/Mobilogram.h>
 
// Kernel classes
#include <OpenMS/KERNEL/MRMTransitionGroup.h>
#include <OpenMS/KERNEL/MSChromatogram.h>
 
// scoring
#include <OpenMS/ANALYSIS/OPENSWATH/PeakPickerMobilogram.h>
 
#include <OpenMS/ANALYSIS/OPENSWATH/DIAScoring.h>
#include <limits>
#include <vector>
namespace OpenMS
{
 
  struct RangeMobility;
  struct RangeMZ;
 
  // Forward declaration for optional mobilogram consumer to stream mobilograms to disk
  class MobilogramParquetConsumer;
 
  class OPENMS_DLLAPI IonMobilityScoring
  {
    typedef OpenSwath::LightCompound CompoundType;
    typedef OpenSwath::LightTransition TransitionType;
    typedef MRMTransitionGroup< MSChromatogram, TransitionType> MRMTransitionGroupType;
 
  public:
 
    IonMobilityScoring();
 
    ~IonMobilityScoring();
 
    static void driftScoring(const SpectrumSequence& spectra,
                             const std::vector<TransitionType> & transitions,
                             OpenSwath_Scores & scores,
                             const double drift_target,
                             RangeMobility im_range,
                             const double dia_extraction_window_,
                             const bool dia_extraction_ppm_,
                             const double drift_extra,
                             const bool apply_im_peak_picking,
                             MobilogramParquetConsumer* mobilogram_consumer = nullptr,
                             const double feature_rt = std::numeric_limits<double>::quiet_NaN(),
                             Int64 feature_id = -1);
 
    static void driftScoringMS1(const SpectrumSequence& spectra,
                                const std::vector<TransitionType> & transitions,
                                OpenSwath_Scores & scores,
                                const double drift_target,
                                RangeMobility im_range,
                                const double dia_extraction_window_,
                                const bool dia_extraction_ppm_,
                                const double drift_extra,
                                MobilogramParquetConsumer* mobilogram_consumer = nullptr,
                                const double feature_rt = std::numeric_limits<double>::quiet_NaN(),
                                Int64 feature_id = -1);
 
    static void driftScoringMS1Contrast(const SpectrumSequence& spectra, const SpectrumSequence& ms1spectrum,
                                        const std::vector<TransitionType> & transitions,
                                        OpenSwath_Scores & scores,
                                        RangeMobility im_range,
                                        const double dia_extraction_window_,
                                        const bool dia_extraction_ppm_,
                                        const double drift_extra,
                                        MobilogramParquetConsumer* mobilogram_consumer = nullptr,
                                        const double feature_rt = std::numeric_limits<double>::quiet_NaN(),
                                        Int64 feature_id = -1);
 
    static void driftIdScoring(const SpectrumSequence& spectra,
                                const std::vector<TransitionType> & transitions,
                                MRMTransitionGroupType& transition_group_detection,
                                OpenSwath_Scores & scores,
                                const double drift_target,
                                RangeMobility im_range,
                                const double dia_extract_window_,
                                const bool dia_extraction_ppm_,
                                const double drift_extra,
                                const bool apply_im_peak_picking,
                                MobilogramParquetConsumer* mobilogram_consumer = nullptr,
                                const double feature_rt = std::numeric_limits<double>::quiet_NaN(),
                                Int64 feature_id = -1);
 
    static void computeIonMobilogram(const SpectrumSequence& spectra,
                              const RangeMZ & mz_range,
                              const RangeMobility & im_range,
                              double & im,
                              double & intensity,
                              Mobilogram & res,
                              double eps);
 
 
  private:
    static std::vector<double> computeGrid_(const std::vector< Mobilogram >& mobilograms, double eps);
 
 
    /*
     @brief Extracts ion mobility values projected onto a grid
 
     For a given ion mobility profile and a grid, compute an ion mobilogram
     across the grid for each ion mobility data point. Returns two data arrays
     for the ion mobilogram: intensity (y) and ion mobility (x). Zero values are
     inserted if no data point was found for a given grid value.
 
     @param[in] profile The ion mobility data
     @param[in] im_grid The grid to be used
     @param[in] eps Epsilon used for computing the ion mobility grid
     @param[in] max_peak_idx The grid position of the maximum
    */
    static void alignToGrid_(const Mobilogram& profile,
                 const std::vector<double>& im_grid,
                 Mobilogram & aligned_profile,
                 double eps,
                 Size & max_peak_idx);
 
    /*
    @brief Extracts intensity values from a vector of Mobilogram objects
 
    This function takes a vector of Mobilogram objects and extracts the intensity
    values from each Mobilogram, storing them in a 2D vector of doubles. The
    resulting vector of intensity values is stored in the provided output parameter.
 
    @param[in] mobilograms A const reference to a vector of Mobilogram objects
                            from which to extract intensity values.
    @param[out] int_values A reference to a vector of vector of doubles where
                            the extracted intensity values will be stored. This
                            vector will be cleared and resized as necessary.
    */
    static void extractIntensities(const std::vector< Mobilogram >& mobilograms,
                                   std::vector<std::vector<double>>& int_values);
 
    static std::vector<double> extractIntensities(const Mobilogram& mobilogram);
 
  };
 
  /*
  @brief Helper function to sum up aligned mobilograms
 
  This function takes a vector of aligned mobilograms and sums them up to create a single Mobilogram object. The resulting Mobilogram object will contain the sum of the intensity values from all the input mobilograms.
 
  @note the input vector of Mobilograms all need to have the same size, otherwise the function will throw a pre-condition exception.
 
  @param[in] aligned_mobilograms A vector of aligned mobilograms
  @return  A Mobilogram object that is the sum of the input mobilograms
  */
  OpenMS::Mobilogram sumAlignedMobilograms(const std::vector<OpenMS::Mobilogram>& aligned_mobilograms);
 
  } // namespace OpenMS