ChromatogramExtractor.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
 
#include <OpenMS/ANALYSIS/OPENSWATH/ChromatogramExtractorAlgorithm.h>
 
#include <OpenMS/CONCEPT/Exception.h>
#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/ANALYSIS/TARGETED/TargetedExperiment.h>
#include <OpenMS/ANALYSIS/MAPMATCHING/TransformationDescription.h>
 
#include <OpenMS/ANALYSIS/OPENSWATH/DATAACCESS/DataAccessHelper.h>
#include <OpenMS/ANALYSIS/OPENSWATH/OpenSwathHelper.h>
 
#include <utility>
 
#ifdef _OPENMP
#include <omp.h>
#endif
 
namespace OpenMS
{
 
  class OPENMS_DLLAPI ChromatogramExtractor :
    public ProgressLogger
  {
 
public:
 
    typedef ChromatogramExtractorAlgorithm::ExtractionCoordinates ExtractionCoordinates;
 
 
    void extractChromatograms(const OpenSwath::SpectrumAccessPtr input, 
                              std::vector< OpenSwath::ChromatogramPtr >& output,
                              const std::vector<ExtractionCoordinates>& extraction_coordinates,
                              double mz_extraction_window,
                              bool ppm,
                              const std::string& filter)
    {
      ChromatogramExtractorAlgorithm().extractChromatograms(input, output, 
          extraction_coordinates, mz_extraction_window, ppm, -1, filter);
    }
 
    void extractChromatograms(const OpenSwath::SpectrumAccessPtr input,
                              std::vector< OpenSwath::ChromatogramPtr >& output,
                              const std::vector<ExtractionCoordinates>& extraction_coordinates,
                              double mz_extraction_window,
                              bool ppm,
                              double im_extraction_window,
                              const std::string& filter) 
    {
      ChromatogramExtractorAlgorithm().extractChromatograms(input, output, 
          extraction_coordinates, mz_extraction_window, ppm, im_extraction_window, filter);
    }
 
    static void prepare_coordinates(std::vector< OpenSwath::ChromatogramPtr > & output_chromatograms,
                                    std::vector< ExtractionCoordinates > & coordinates,
                                    const OpenSwath::LightTargetedExperiment & transition_exp_used,
                                    const double rt_extraction_window,
                                    const bool ms1 = false,
                                    const int ms1_isotopes = 0);
 
    template <typename TransitionExpT>
    static void return_chromatogram(const std::vector< OpenSwath::ChromatogramPtr > & chromatograms,
                                    const std::vector< ChromatogramExtractor::ExtractionCoordinates > & coordinates,
                                    TransitionExpT& transition_exp_used,
                                    SpectrumSettings settings,
                                    std::vector<OpenMS::MSChromatogram > & output_chromatograms,
                                    bool ms1,
                                    double im_extraction_width = 0.0)
    {
      typedef std::map<std::string, const typename TransitionExpT::Transition* > TransitionMapType;
      TransitionMapType trans_map;
      for (Size i = 0; i < transition_exp_used.getTransitions().size(); i++)
      {
        trans_map[transition_exp_used.getTransitions()[i].getNativeID()] = &transition_exp_used.getTransitions()[i];
      }
 
      // The lookups of the peptide / compound (and the data processing) are not thread-safe: collect
      // them first, then build the chromatograms in parallel (if called from a single thread).
      struct ChromatogramIds
      {
        const typename TransitionExpT::Transition* transition = nullptr;
        bool has_id = false;
        int prec_charge = 0;
        std::string sequence;
      };
      std::vector<ChromatogramIds> ids(chromatograms.size());
      for (Size i = 0; i < chromatograms.size(); i++)
      {
        const ChromatogramExtractor::ExtractionCoordinates & coord = coordinates[i];
        ChromatogramIds& id = ids[i];
        if (ms1)
        {
          // extract compound / peptide id from transition and store in
          // more-or-less default field
          std::string transition_group_id = OpenSwathHelper::computeTransitionGroupId(coord.id);
          if (!transition_group_id.empty())
          {
            id.has_id = true;
            id.sequence = extract_id_(transition_exp_used, transition_group_id, id.prec_charge);
          }
        }
        else
        {
          id.transition = trans_map[coord.id];
          // extract compound / peptide id from transition and store in
          // more-or-less default field
          id.has_id = true;
          if (!id.transition->getPeptideRef().empty())
          {
            id.sequence = extract_id_(transition_exp_used, id.transition->getPeptideRef(), id.prec_charge);
          }
          else
          {
            id.sequence = extract_id_(transition_exp_used, id.transition->getCompoundRef(), id.prec_charge);
          }
        }
      }
      if (!chromatograms.empty())
      {
        for (Size j = 0; j < settings.getDataProcessing().size(); ++j)
        {
          settings.getDataProcessing()[j]->setMetaValue("performed_on_spectra", "true");
        }
      }
 
      const Size offset = output_chromatograms.size();
      output_chromatograms.resize(offset + chromatograms.size());
      [[maybe_unused]] bool parallel = false;
#ifdef _OPENMP
      parallel = omp_in_parallel() == 0 && chromatograms.size() >= 256;
#pragma omp parallel for schedule(dynamic, 64) if (parallel)
#endif
      for (SignedSize i = 0; i < static_cast<SignedSize>(chromatograms.size()); i++)
      {
        const OpenSwath::ChromatogramPtr & chromptr = chromatograms[i];
        const ChromatogramExtractor::ExtractionCoordinates & coord = coordinates[i];
        const ChromatogramIds& id = ids[i];
 
        // copy data
        OpenMS::MSChromatogram chrom;
        OpenSwathDataAccessHelper::convertToOpenMSChromatogram(chromptr, chrom);
        chrom.setNativeID(coord.id);
 
        // Create precursor and set
        // 1) the target m/z
        // 2) the isolation window (upper/lower)
        // 3) the peptide sequence
        Precursor prec;
        if (ms1) 
        {
          prec.setMZ(coord.mz);
          chrom.setChromatogramType(ChromatogramSettings::ChromatogramType::BASEPEAK_CHROMATOGRAM);
        }
        else 
        {
          const typename TransitionExpT::Transition& transition = *id.transition;
 
          prec.setMZ(transition.getPrecursorMZ());
          if (!settings.getPrecursors().empty())
          {
            prec.setIsolationWindowLowerOffset(settings.getPrecursors()[0].getIsolationWindowLowerOffset());
            prec.setIsolationWindowUpperOffset(settings.getPrecursors()[0].getIsolationWindowUpperOffset());
          }
 
          // Create product and set its m/z
          Product prod;
          prod.setMZ(transition.getProductMZ());
          chrom.setProduct(prod);
          chrom.setChromatogramType(ChromatogramSettings::ChromatogramType::SELECTED_REACTION_MONITORING_CHROMATOGRAM);
        }
        if (id.has_id)
        {
          prec.setCharge(id.prec_charge);
          prec.setMetaValue("peptide_sequence", id.sequence);
        }
 
        if (coord.ion_mobility >= 0 && im_extraction_width > 0.0)
        {
          prec.setDriftTime(coord.ion_mobility);
          prec.setDriftTimeWindowLowerOffset(im_extraction_width / 2.0);
          prec.setDriftTimeWindowUpperOffset(im_extraction_width / 2.0);
        }
        chrom.setPrecursor(prec);
 
        // Set the rest of the meta-data
        chrom.setInstrumentSettings(settings.getInstrumentSettings());
        chrom.setAcquisitionInfo(settings.getAcquisitionInfo());
        chrom.setSourceFile(settings.getSourceFile());
 
        for (Size j = 0; j < settings.getDataProcessing().size(); ++j)
        {
          chrom.getDataProcessing().push_back(settings.getDataProcessing()[j]);
        }
        output_chromatograms[offset + i] = std::move(chrom);
      }
    }
 
 
private:
    template <typename TransitionExpT>
    static std::string extract_id_(TransitionExpT& transition_exp_used, const std::string& id, int& prec_charge);
 
    template <class SpectrumSettingsT, class ChromatogramT>
    void prepareSpectra_(SpectrumSettingsT& settings,
                         std::vector<ChromatogramT>& chromatograms,
                         OpenMS::TargetedExperiment& transition_exp)
    {
      // first prepare all the spectra (but leave them empty)
      for (Size i = 0; i < transition_exp.getTransitions().size(); i++)
      {
        const ReactionMonitoringTransition* transition = &transition_exp.getTransitions()[i];
 
        // 1) and 2) Extract precursor m/z and isolation window
        ChromatogramT chrom;
        Precursor prec;
        prec.setMZ(transition->getPrecursorMZ());
        if (settings.getPrecursors().size() > 0)
        {
          prec.setIsolationWindowLowerOffset(settings.getPrecursors()[0].getIsolationWindowLowerOffset());
          prec.setIsolationWindowUpperOffset(settings.getPrecursors()[0].getIsolationWindowUpperOffset());
        }
 
        // 3) set precursor peptide sequence / compound id in more-or-less default field
        std::string pepref = transition->getPeptideRef();
        for (Size pep_idx = 0; pep_idx < transition_exp.getPeptides().size(); pep_idx++)
        {
          const OpenMS::TargetedExperiment::Peptide* pep = &transition_exp.getPeptides()[pep_idx];
          if (pep->id == pepref)
          {
            prec.setMetaValue("peptide_sequence", pep->sequence);
            break;
          }
        }
        std::string compref = transition->getCompoundRef();
        for (Size comp_idx = 0; comp_idx < transition_exp.getCompounds().size(); comp_idx++)
        {
          const OpenMS::TargetedExperiment::Compound* comp = &transition_exp.getCompounds()[comp_idx];
          if (comp->id == compref)
          {
            prec.setMetaValue("peptide_sequence",std::string(comp->id) );
            break;
          }
        }
 
        // add precursor to spectrum
        chrom.setPrecursor(prec);
 
        // 4) Create product and set its m/z
        Product prod;
        prod.setMZ(transition->getProductMZ());
        chrom.setProduct(prod);
 
        // 5) Set the rest of the meta-data
        chrom.setInstrumentSettings(settings.getInstrumentSettings());
        chrom.setAcquisitionInfo(settings.getAcquisitionInfo());
        chrom.setSourceFile(settings.getSourceFile());
 
        for (Size j = 0; j < settings.getDataProcessing().size(); ++j)
        {
          settings.getDataProcessing()[j]->setMetaValue("performed_on_spectra", "true");
          chrom.getDataProcessing().push_back(settings.getDataProcessing()[j]);
        }
 
        // Set the id of the chromatogram, using the id of the transition (this gives directly the mapping of the two)
        chrom.setNativeID(transition->getNativeID());
        chrom.setChromatogramType(ChromatogramSettings::ChromatogramType::SELECTED_REACTION_MONITORING_CHROMATOGRAM);
        chromatograms.push_back(chrom);
      }
 
    }
 
    bool outsideExtractionWindow_(const ReactionMonitoringTransition& transition,
                                  double current_rt,
                                  const TransformationDescription& trafo,
                                  double rt_extraction_window);
 
    int getFilterNr_(const std::string& filter);
 
    void populatePeptideRTMap_(OpenMS::TargetedExperiment& transition_exp,
                               double rt_extraction_window);
 
    std::map<std::string, double> PeptideRTMap_;
 
  };
    
  // Specialization for template (LightTargetedExperiment)
  template<>
  inline std::string ChromatogramExtractor::extract_id_<OpenSwath::LightTargetedExperiment>(OpenSwath::LightTargetedExperiment& transition_exp_used,
                                                                                       const std::string& id,
                                                                                       int & prec_charge)
  {
    const OpenSwath::LightCompound& comp = transition_exp_used.getCompoundByRef(id);
    prec_charge = comp.charge;
    if (!comp.sequence.empty())
    {
      return comp.sequence;        // peptide path
    }
    // Fall through to compound_name (may itself be empty — that is intentional
    // for iRT calibration peptides, which carry empty sequence and no
    // CompoundName user-param. Downstream consumers expect an empty
    // peptide_sequence userParam in that case).
    return comp.compound_name;
  }
 
  // Const-qualified template specialization for extract_id_.
  // This specialization handles const LightTargetedExperiment parameters by forwarding
  // to the non-const implementation (via const_cast) to avoid linker errors from
  // duplicate template instantiations when both const and non-const versions are used.
  template<>
  inline std::string ChromatogramExtractor::extract_id_<const OpenSwath::LightTargetedExperiment>(const OpenSwath::LightTargetedExperiment& transition_exp_used,
                                                                                               const std::string& id,
                                                                                               int & prec_charge)
  {
    // forward to non-const implementation
    return extract_id_<OpenSwath::LightTargetedExperiment>(const_cast<OpenSwath::LightTargetedExperiment&>(transition_exp_used), id, prec_charge);
  }
 
  // Specialization for template (TargetedExperiment)
  template<>
  inline std::string ChromatogramExtractor::extract_id_<OpenMS::TargetedExperiment>(OpenMS::TargetedExperiment& transition_exp_used,
                                                                               const std::string& id,
                                                                               int & prec_charge)
  {
    if (transition_exp_used.hasPeptide(id))
    {
      const TargetedExperiment::Peptide p = transition_exp_used.getPeptideByRef(id);
      if (p.hasCharge()) {prec_charge = p.getChargeState();}
      return p.sequence;
    }
    else if (transition_exp_used.hasCompound(id))
    {
      const TargetedExperiment::Compound c = transition_exp_used.getCompoundByRef(id);
      if (c.hasCharge()) {prec_charge = c.getChargeState();}
      return c.id;
    }
    else
    {
      return "";
    }
  }
}