openswathalgo/include/OpenMS/OPENSWATHALGO/DATAACCESS/ISpectrumAccess.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, Witold Wolski $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/OPENSWATHALGO/OpenSwathAlgoConfig.h>
 
#include <OpenMS/OPENSWATHALGO/DATAACCESS/DataStructures.h>
#include <memory>
#include <string>
#include <vector>
 
namespace OpenMS
{
  using SpectrumSequence = std::vector<OpenSwath::SpectrumPtr>;  
}
namespace OpenSwath
{
 
  using SpectrumSequence = OpenMS::SpectrumSequence;
  class OPENSWATHALGO_DLLAPI ISpectrumAccess
  {
public:
    virtual ~ISpectrumAccess();
 
    virtual std::shared_ptr<ISpectrumAccess> lightClone() const = 0;
 
    virtual SpectrumPtr getSpectrumById(int id) = 0;
 
    SpectrumPtr getSpectrumById(int id, double drift_start, double drift_end );
 
    virtual std::vector<std::size_t> getSpectraByRT(double RT, double deltaRT) const = 0;
    virtual size_t getNrSpectra() const = 0;
    virtual SpectrumMeta getSpectrumMetaById(int id) const = 0;
 
    virtual ChromatogramPtr getChromatogramById(int id) = 0;
    virtual std::size_t getNrChromatograms() const = 0;
    virtual std::string getChromatogramNativeID(int id) const = 0;
 
    /* @brief Fetches a spectrumSequence (multiple spectra pointers) closest to the given RT
     *
     * Returns the spectrum closest to @p RT plus up to @p nr_spectra_to_fetch / 2 neighbours
     * on either side, in alternating order around the closest spectrum (the result is not
     * sorted by RT). An odd @p nr_spectra_to_fetch yields at most that many spectra, an even
     * value one more, and any value below 2 only the closest spectrum. If no spectrum lies
     * at or after @p RT (e.g. @p RT is past the last spectrum), the sequence is empty.
     *
     * @p RT = target RT
     * @p nr_spectra_to_fetch = # spectra around target RT to fetch (see above for the resulting sequence length)
    */
    SpectrumSequence getMultipleSpectra(double RT, int nr_spectra_to_fetch);
 
    /* @brief Fetches a spectrumSequence (multiple spectra pointers) closest to the given RT. Filters all spectra by specified @p drift_start and @p drift_end
     *
     * The returned sequence is built as described for the driftless overload above: the
     * closest spectrum plus up to @p nr_spectra_to_fetch / 2 neighbours per side, in
     * alternating order (an even value yields one spectrum more, any value below 2 only
     * the closest spectrum); if no spectrum lies at or after @p RT, the sequence is empty.
     *
     * @p RT = target RT
     * @p nr_spectra_to_fetch = # spectra around target RT to fetch (see above for the resulting sequence length)
    */
    SpectrumSequence getMultipleSpectra(double RT, int nr_spectra_to_fetch, double drift_start, double drift_end);
 
    static SpectrumPtr filterByDrift(const SpectrumPtr& input, double drift_start, double drift_end)
    {
      // NOTE: this function is very inefficient because filtering unsorted array
      //OPENMS_PRECONDITION(drift_start <= 0, "Cannot filter by drift time if drift_start is not set");
      //OPENMS_PRECONDITION(drift_end - drift_start < 0, "Cannot filter by drift time if range is empty");
      //OPENMS_PRECONDITION(input->getDriftTimeArray() != nullptr, "Cannot filter by drift time if no drift time is available.");
 
      //if (input->getDriftTimeArray() == nullptr)
      //{
        //throw Exception::NullPointer(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION);
      //}
 
      OpenSwath::SpectrumPtr output(new OpenSwath::Spectrum);
 
      OpenSwath::BinaryDataArrayPtr mz_arr = input->getMZArray();
      OpenSwath::BinaryDataArrayPtr int_arr = input->getIntensityArray();
      OpenSwath::BinaryDataArrayPtr im_arr = input->getDriftTimeArray();
 
      auto mz_it = mz_arr->data.cbegin();
      auto int_it = int_arr->data.cbegin();
      auto im_it = im_arr->data.cbegin();
      auto mz_end = mz_arr->data.cend();
 
      OpenSwath::BinaryDataArrayPtr mz_arr_out(new OpenSwath::BinaryDataArray);
      OpenSwath::BinaryDataArrayPtr intens_arr_out(new OpenSwath::BinaryDataArray);
      OpenSwath::BinaryDataArrayPtr im_arr_out(new OpenSwath::BinaryDataArray);
      im_arr_out->description = im_arr->description;
 
      while (mz_it != mz_end)
      {
        if ( (drift_start <= *im_it) && (drift_end >= *im_it) )
        {
          mz_arr_out->data.push_back( *mz_it );
          intens_arr_out->data.push_back( *int_it );
          im_arr_out->data.push_back( *im_it );
        }
        ++mz_it;
        ++int_it;
        ++im_it;
      }
      output->setMZArray(mz_arr_out);
      output->setIntensityArray(intens_arr_out);
      output->getDataArrays().push_back(im_arr_out);
      return output;
  }
 
 
   };
 
  typedef std::shared_ptr<ISpectrumAccess> SpectrumAccessPtr;
}