RangeUtils.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: Timo Sachsenberg$
// $Authors: Marc Sturm, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <functional>
#include <algorithm>
#include <vector>
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/METADATA/Precursor.h>
#include <OpenMS/METADATA/IonSource.h>
#include <OpenMS/DATASTRUCTURES/ListUtils.h>
#include <OpenMS/CONCEPT/LogStream.h>
 
namespace OpenMS
{
  template <class MetaContainer>
  class HasMetaValue
  {
public:
    HasMetaValue(String metavalue, bool reverse = false) :
      metavalue_key_(metavalue),
      reverse_(reverse)
    {}
 
    inline bool operator()(const MetaContainer& s) const
    {
      bool has_meta_value = s.metaValueExists(metavalue_key_);
      // XOR(^): same as 'if (rev_) return !(test) else return test;' where (test) is the condition;   Speed: XOR is about 25% faster in VS10
      return reverse_ ^ has_meta_value;
    }
 
protected:
    String metavalue_key_;
    bool reverse_;
  };
 
 
  template <class SpectrumType>
  class InRTRange
  {
public:
    InRTRange(double min, double max, bool reverse = false) :
      min_(min),
      max_(max),
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      double tmp = s.getRT();
      // XOR(^): same as 'if (rev_) return !(test) else return test;' where (test) is the condition;   Speed: XOR is about 25% faster in VS10
      return reverse_ ^ (min_ <= tmp && tmp <= max_);
    }
 
protected:
    double min_, max_;
    bool reverse_;
  };
 
  template <class SpectrumType>
  class InMSLevelRange
  {
public:
    InMSLevelRange(const IntList& levels, bool reverse = false) :
      levels_(levels),
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      Int tmp = s.getMSLevel();
      // XOR(^): same as 'if (rev_) return !(test) else return test;' where (test) is the condition;   Speed: XOR is about 25% faster in VS10
      return reverse_ ^ (std::find(levels_.begin(), levels_.end(), tmp) != levels_.end());
    }
 
protected:
    IntList levels_;
    bool reverse_;
  };
 
  template <class SpectrumType>
  class HasScanMode
  {
public:
    HasScanMode(Int mode, bool reverse = false) :
      mode_(mode),
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      // XOR(^): same as 'if (rev_) return !(test) else return test;' where (test) is the condition;   Speed: XOR is about 25% faster in VS10
      return reverse_ ^ (s.getInstrumentSettings().getScanMode() == mode_);
    }
 
protected:
    Int mode_;
    bool reverse_;
  };
 
  template <class SpectrumType>
  class HasScanPolarity
  {
public:
    HasScanPolarity(IonSource::Polarity polarity, bool reverse = false) :
      polarity_(polarity),
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      // XOR(^): same as 'if (rev_) return !(test) else return test;' where (test) is the condition;   Speed: XOR is about 25% faster in VS10
      return reverse_ ^ (s.getInstrumentSettings().getPolarity() == polarity_);
    }
 
protected:
    IonSource::Polarity polarity_;
    bool reverse_;
  };
 
 
  template <class SpectrumType>
  class IsEmptySpectrum
  {
public:
    explicit IsEmptySpectrum(bool reverse = false) :
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      // XOR(^): same as 'if (rev_) return !(test) else return test;' where (test) is the condition;   Speed: XOR is about 25% faster in VS10
      return reverse_ ^ s.empty();
    }
 
protected:
    bool reverse_;
  };
 
  template <class SpectrumType>
  class IsZoomSpectrum
  {
public:
    explicit IsZoomSpectrum(bool reverse = false) :
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      // XOR(^): same as 'if (rev_) return !(test) else return test;' where (test) is the condition;   Speed: XOR is about 25% faster in VS10
      return reverse_ ^ s.getInstrumentSettings().getZoomScan();
    }
 
protected:
    bool reverse_;
  };
 
 
  template <class SpectrumType>
  class HasActivationMethod
  {
public:
    HasActivationMethod(const StringList& methods, bool reverse = false) :
      methods_(methods),
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      for (const Precursor& p : s.getPrecursors())
      {
        for (const Precursor::ActivationMethod am : p.getActivationMethods())
        {
          if (ListUtils::contains(methods_, Precursor::NamesOfActivationMethod[static_cast<size_t>(am)]))
          {
            // found matching activation method
            if (reverse_) return false;
            else return true;
          }
        }
      }
 
      return reverse_;
    }
 
protected:
    StringList methods_;
    bool reverse_;
  };
 
  template <class SpectrumType>
  class InPrecursorMZRange
  {
public:
    InPrecursorMZRange(const double& mz_left, const double& mz_right, bool reverse = false) :
      mz_left_(mz_left),
      mz_right_(mz_right),
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      for (std::vector<Precursor>::const_iterator it = s.getPrecursors().begin(); it != s.getPrecursors().end(); ++it)
      {
        //std::cerr << mz_left_ << " " << mz_right_ << " " << it->getMZ() << "\n";
        if (!(mz_left_ <= it->getMZ() && it->getMZ() <= mz_right_))
        { // found PC outside of allowed window
          if (reverse_) return true;
          else return false;
        }
      }
 
      if (reverse_) return false;
      else return true;
    }
 
protected:
    double mz_left_;
    double mz_right_;
    bool reverse_;
  };
 
 
  template <class SpectrumType>
  class HasPrecursorCharge
  {
public:
    HasPrecursorCharge(const IntList& charges, bool reverse = false) :
      charges_(charges),
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      bool match = false;
      for (std::vector<Precursor>::const_iterator it = s.getPrecursors().begin(); it != s.getPrecursors().end(); ++it)
      {
        Int tmp = it->getCharge();
        match = match || (std::find(charges_.begin(), charges_.end(), tmp) != charges_.end());
      }
 
      if (reverse_) return !match;
      else return match;
    }
 
protected:
    IntList charges_;
    bool reverse_;
  };
 
 
  template <class PeakType>
  class InMzRange
  {
public:
    InMzRange(double min, double max, bool reverse = false) :
      min_(min),
      max_(max),
      reverse_(reverse)
    {}
 
    inline bool operator()(const PeakType& p) const
    {
      double tmp = p.getPosition()[0];
      // XOR(^): same as 'if (rev_) return !(test) else return test;' where (test) is the condition;   Speed: XOR is about 25% faster in VS10
      return reverse_ ^ (min_ <= tmp && tmp <= max_);
    }
 
protected:
    double min_, max_;
    bool reverse_;
  };
 
  template <class PeakType>
  class InIntensityRange
  {
public:
    InIntensityRange(double min, double max, bool reverse = false) :
      min_(min),
      max_(max),
      reverse_(reverse)
    {}
 
    inline bool operator()(const PeakType& p) const
    {
      double tmp = p.getIntensity();
      // XOR(^): same as 'if (rev_) return !(test) else return test;' where (test) is the condition;   Speed: XOR is about 25% faster in VS10
      return reverse_ ^ (min_ <= tmp && tmp <= max_);
    }
 
protected:
    double min_, max_;
    bool reverse_;
  };
 
  template <class SpectrumType>
  class IsInCollisionEnergyRange
  {
public:
    IsInCollisionEnergyRange(double min, double max, bool reverse = false) :
      min_energy_(min),
      max_energy_(max),
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      // leave non-fragmentation spectra untouched
      if (s.getMSLevel() == 1) return false;
 
      bool isIn = false;
      bool hasCollisionEnergy = false;
      for (std::vector<Precursor>::const_iterator it = s.getPrecursors().begin(); it != s.getPrecursors().end(); ++it)
      {
        if (it->metaValueExists("collision energy"))
        {
          hasCollisionEnergy = true;
          double cE = it->getMetaValue("collision energy");
          isIn |= !(cE > max_energy_ || cE < min_energy_);
        }
      }
 
      // we accept all spectra that have no collision energy value
      if (!hasCollisionEnergy) return false;
 
      if (reverse_) return !isIn;
      else return isIn;
    }
 
private:
    double min_energy_, max_energy_;
    bool reverse_;
  };
 
  template <class SpectrumType>
  class IsInIsolationWindowSizeRange
  {
 
public:
    IsInIsolationWindowSizeRange(double min_size, double max_size, bool reverse = false) :
      min_size_(min_size),
      max_size_(max_size),
      reverse_(reverse)
    {}
 
    inline bool operator()(const SpectrumType& s) const
    {
      // leave non-fragmentation spectra untouched
      if (s.getMSLevel() == 1) return false;
 
      bool isIn = false;
      for (std::vector<Precursor>::const_iterator it = s.getPrecursors().begin(); it != s.getPrecursors().end(); ++it)
      {
        const double isolationWindowSize = it->getIsolationWindowUpperOffset() + it->getIsolationWindowLowerOffset();
        isIn |= !(isolationWindowSize > max_size_ || isolationWindowSize < min_size_);
      }
 
      if (reverse_) return !isIn;
      else return isIn;
    }
 
private:
    double min_size_, max_size_;
    bool reverse_;
  };
 
  template <class SpectrumType>
  class IsInIsolationWindow
  {
 
public:
    IsInIsolationWindow(std::vector<double> vec_mz, bool reverse = false) :
      vec_mz_(vec_mz),
      reverse_(reverse)
    {
      std::sort(vec_mz_.begin(), vec_mz_.end());
    }
 
    inline bool operator()(const SpectrumType& s) const
    {
      // leave non-fragmentation spectra untouched
      if (s.getMSLevel() == 1) return false;
 
      bool isIn = false;
      for (std::vector<Precursor>::const_iterator it = s.getPrecursors().begin(); it != s.getPrecursors().end(); ++it)
      {
        if (it->getIsolationWindowLowerOffset() == 0 || it->getIsolationWindowUpperOffset() == 0)
        {
          OPENMS_LOG_WARN << "IsInIsolationWindow(): Lower/Upper Offset for Precursor Isolation Window is Zero! " << 
            "Filtering will probably be too strict (unless you hit the exact precursor m/z)!" << std::endl;
        }
        const double lower_mz = it->getMZ() - it->getIsolationWindowLowerOffset();
        std::vector<double>::const_iterator it_mz = std::lower_bound(vec_mz_.begin(), vec_mz_.end(), lower_mz);
        if (it_mz != vec_mz_.end()) // left side ok
        { // right side?
          const double upper_mz = it->getMZ() + it->getIsolationWindowUpperOffset();
          isIn |= (*it_mz <= upper_mz);
        }
      }
 
      if (reverse_) return !isIn;
      else return isIn;
    }
 
private:
    std::vector<double> vec_mz_;
    bool reverse_;
  };
 
} // namespace OpenMS