OpenSwathWorkflow.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
 
// Interfaces
 
#include <OpenMS/INTERFACES/IMSDataConsumer.h>
#include <OpenMS/OPENSWATHALGO/DATAACCESS/DataStructures.h>
#include <OpenMS/OPENSWATHALGO/DATAACCESS/ISpectrumAccess.h>
#include <OpenMS/OPENSWATHALGO/DATAACCESS/TransitionExperiment.h>
 
// Kernel and implementations
#include <OpenMS/ANALYSIS/OPENSWATH/DATAACCESS/SpectrumAccessOpenMS.h>
#include <OpenMS/ANALYSIS/OPENSWATH/DATAACCESS/SpectrumAccessOpenMSInMemory.h>
#include <OpenMS/ANALYSIS/OPENSWATH/DATAACCESS/SpectrumAccessTransforming.h>
#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/OPENSWATHALGO/DATAACCESS/SwathMap.h>
 
// Helpers
#include <OpenMS/ANALYSIS/OPENSWATH/OpenSwathHelper.h>
// #include <OpenMS/ANALYSIS/OPENSWATH/DATAACCESS/DataAccessHelper.h>
#include <OpenMS/ANALYSIS/OPENSWATH/DATAACCESS/SimpleOpenMSSpectraAccessFactory.h>
#include <OpenMS/ANALYSIS/OPENSWATH/OpenSwathOSWWriter.h>
 
// Algorithms
#include <OpenMS/ANALYSIS/OPENSWATH/ChromatogramExtractor.h>
#include <OpenMS/ANALYSIS/OPENSWATH/MRMFeatureFinderScoring.h>
#include <OpenMS/ANALYSIS/OPENSWATH/MRMRTNormalizer.h>
#include <OpenMS/ANALYSIS/OPENSWATH/MRMTransitionGroupPicker.h>
#include <OpenMS/ANALYSIS/OPENSWATH/SwathMapMassCorrection.h>
#include <OpenMS/PROCESSING/RESAMPLING/LinearResamplerAlign.h>
#include <cassert>
#include <limits>
#include <string>
#include <unordered_map>
#include <vector>
 
// #define OPENSWATH_WORKFLOW_DEBUG
 
// The workflow class
namespace OpenMS
{
 
  struct ChromExtractParams
  {
    double min_upper_edge_dist;
    double mz_extraction_window;
    double im_extraction_window;
    bool ppm;
    std::string extraction_function;
    double rt_extraction_window;
    double extra_rt_extract;
  };
 
  class OPENMS_DLLAPI OpenSwathWorkflowBase :
    public ProgressLogger
  {
 
protected:
 
    OpenSwathWorkflowBase() :
      use_ms1_traces_(false),
      use_ms1_ion_mobility_(false),
      prm_(false),
      pasef_(false),
      mrm_(false),
      threads_outer_loop_(-1)
    {
    }
 
    OpenSwathWorkflowBase(bool use_ms1_traces, bool use_ms1_ion_mobility, bool prm, bool pasef, bool mrm, int threads_outer_loop) :
      use_ms1_traces_(use_ms1_traces),
      use_ms1_ion_mobility_(use_ms1_ion_mobility),
      prm_(prm),
      pasef_(pasef),
      mrm_(mrm),
      threads_outer_loop_(threads_outer_loop)
    {
    }
 
    void MS1Extraction_(const OpenSwath::SpectrumAccessPtr& ms1_map,
                        const std::vector<OpenSwath::SwathMap>& swath_maps,
                        std::vector<MSChromatogram>& ms1_chromatograms,
                        const ChromExtractParams& cp,
                        const OpenSwath::LightTargetedExperiment& transition_exp,
                        const TransformationDescription& trafo_inverse,
                        bool ms1_only = false,
                        int ms1_isotopes = 0);
 
    void prepareExtractionCoordinates_(std::vector< OpenSwath::ChromatogramPtr > & chrom_list,
                                       std::vector< ChromatogramExtractorAlgorithm::ExtractionCoordinates > & coordinates,
                                       const OpenSwath::LightTargetedExperiment & transition_exp_used,
                                       const TransformationDescription& trafo_inverse,
                                       const ChromExtractParams & cp,
                                       const bool ms1 = false,
                                       const int ms1_isotopes = -1) const;
 
 
    OpenSwath::SpectrumAccessPtr ms1_map_ = nullptr;
 
    bool use_ms1_traces_;
 
    bool use_ms1_ion_mobility_;
 
    bool prm_;
 
    bool pasef_;
 
    bool mrm_;
 
    int threads_outer_loop_;
 
};
 
  struct OPENMS_DLLAPI ChromatogramIndex
  {
    std::unordered_map<std::string, int> ms2; 
    std::unordered_map<std::string, int> ms1; 
 
    void build(const std::vector<MSChromatogram>& ms2_chromatograms, const std::vector<MSChromatogram>& ms1_chromatograms);
  };
 
  class OPENMS_DLLAPI OpenSwathWorkflow :
    public OpenSwathWorkflowBase
  {
    typedef OpenSwath::LightTransition TransitionType;
    typedef MRMTransitionGroup< MSChromatogram, TransitionType> MRMTransitionGroupType;
 
  public:
 
    OpenSwathWorkflow(bool use_ms1_traces, bool use_ms1_ion_mobility, bool prm, bool pasef, bool mrm, int threads_outer_loop) :
    OpenSwathWorkflowBase(use_ms1_traces, use_ms1_ion_mobility, prm, pasef, mrm, threads_outer_loop)
    {
    }
 
    OpenSwath::SpectrumAccessPtr loadMS1Map(const std::vector<OpenSwath::SwathMap>& swath_maps, bool load_into_memory);
 
  void performExtraction(const std::vector<OpenSwath::SwathMap>& swath_maps,
               const TransformationDescription& rt_trafo,
               const ChromExtractParams & chromatogram_extraction_params,
               const ChromExtractParams & ms1_chromatogram_extraction_params,
               const Param & feature_finder_param,
               const OpenSwath::LightTargetedExperiment& assay_library,
               FeatureMap& result_featureFile,
               bool store_features_in_featureFile,
               OpenSwathOSWWriter & result_osw,
               Interfaces::IMSDataConsumer * result_chromatograms,
               int batchSize,
               int ms1_isotopes,
               bool load_into_memory,
              const Param & mrm_mapping_param = Param(),
              class MobilogramParquetConsumer * mobilogram_consumer = nullptr,
              int innerBatchSize = -1,
              int maxConcurrentSwaths = -1);
 
  protected:
 
 
    void writeOutFeaturesAndChroms_(std::vector< OpenMS::MSChromatogram > & chromatograms,
                                    std::vector< MSChromatogram >& ms1_chromatograms,
                                    const FeatureMap & featureFile,
                                    FeatureMap& out_featureFile,
                                    bool store_features,
                                    Interfaces::IMSDataConsumer * chromConsumer);
 
  void scoreAllChromatograms_(
        const std::vector<OpenMS::MSChromatogram>& ms2_chromatograms,
        const std::vector<OpenMS::MSChromatogram>& ms1_chromatograms,
        const std::vector<OpenSwath::SwathMap>& swath_maps,
        const OpenSwath::LightTargetedExperiment& transition_exp,
        const Param& feature_finder_param,
        const TransformationDescription& trafo,
        const double rt_extraction_window,
        FeatureMap& output,
        OpenSwathOSWWriter& osw_writer,
        int nr_ms1_isotopes = 0,
        bool ms1only = false,
        class MobilogramParquetConsumer * mobilogram_consumer = nullptr,
        OpenSwathOSWWriter::OSWData* deferred_osw_output = nullptr,
        const ChromatogramIndex* chromatogram_index = nullptr) const;
 
    void selectCompoundsForBatch_(const OpenSwath::LightTargetedExperiment& transition_exp_used_all,
      OpenSwath::LightTargetedExperiment& transition_exp_used, int batch_size, size_t batch_idx);
 
    void copyBatchTransitions_(const std::vector<OpenSwath::LightCompound>& used_compounds,
      const std::vector<OpenSwath::LightTransition>& all_transitions,
      std::vector<OpenSwath::LightTransition>& output);
  };
}