IsotopeDistribution.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: Chris Bielow $
// $Authors: Clemens Groepl, Andreas Bertsch, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/KERNEL/Peak1D.h>
#include <OpenMS/CONCEPT/HashUtils.h>
#include <functional>
#include <vector>
 
namespace OpenMS
{
  class Element; 
 
  class OPENMS_DLLAPI IsotopeDistribution
  {
public:
 
 
 
    typedef Peak1D MassAbundance;
    typedef std::vector<MassAbundance> ContainerType;
    typedef ContainerType::iterator iterator;
    typedef ContainerType::iterator Iterator;
    typedef ContainerType::const_iterator const_iterator;
    typedef ContainerType::const_iterator ConstIterator;
 
    typedef ContainerType::reverse_iterator reverse_iterator;
    typedef ContainerType::reverse_iterator ReverseIterator;
    typedef ContainerType::const_reverse_iterator const_reverse_iterator;
    typedef ContainerType::const_reverse_iterator ConstReverseIterator;
 
    enum Sorted {INTENSITY, MASS, UNDEFINED};
 
 
 
    IsotopeDistribution();
 
    IsotopeDistribution(const IsotopeDistribution&) = default;
 
    IsotopeDistribution(IsotopeDistribution&&) noexcept = default;
 
    virtual ~IsotopeDistribution() = default;
 
 
 
    void set(const ContainerType & distribution);
 
    void set(ContainerType && distribution);
 
    const ContainerType & getContainer() const;
 
    Peak1D::CoordinateType getMax() const;
 
    Peak1D::CoordinateType getMin() const;
 
    Peak1D getMostAbundant() const;
 
    Size size() const;
 
    void clear();
 
    // resizes distribution container
    void resize(UInt size);
 
    void trimIntensities(double cutoff);
 
    void sortByIntensity();
 
    void sortByMass();
 
    void renormalize();
 
    void merge(double resolution, double min_prob);
 
    void trimRight(double cutoff);
 
    void trimLeft(double cutoff);
 
    double averageMass() const;
 
 
 
    IsotopeDistribution & operator=(const IsotopeDistribution & isotope_distribution);
 
    bool operator==(const IsotopeDistribution & isotope_distribution) const;
 
    bool operator!=(const IsotopeDistribution & isotope_distribution) const;
 
    bool operator<(const IsotopeDistribution & isotope_distribution) const;
 
 
    inline Iterator begin() { return distribution_.begin(); }
 
    inline Iterator end()   { return distribution_.end(); }
 
    inline ConstIterator begin() const { return distribution_.begin(); }
 
    inline ConstIterator end() const { return distribution_.end(); }
 
    inline ReverseIterator rbegin() { return distribution_.rbegin(); }
 
    inline ReverseIterator rend()   { return distribution_.rend(); }
 
    inline ConstReverseIterator rbegin() const { return distribution_.rbegin(); }
 
    inline ConstReverseIterator rend() const { return distribution_.rend(); }
 
    inline void insert(const Peak1D::CoordinateType& mass, const Peak1D::IntensityType& intensity)
    {
      distribution_.push_back(Peak1D(mass, intensity));
    }
 
 
 
    Peak1D& operator[](const Size& index){ return distribution_[index];}
    const Peak1D& operator[](const Size& index) const { return distribution_[index]; }
 
protected:   
 
    void sort_(std::function<bool(const MassAbundance& p1, const MassAbundance& p2)> sorter);
 
    void transform_(std::function<void(MassAbundance&)> lambda);
 
    ContainerType distribution_;
  };
 
 
} // namespace OpenMS
 
// Hash function specialization for IsotopeDistribution
namespace std
{
  template<>
  struct hash<OpenMS::IsotopeDistribution>
  {
    std::size_t operator()(const OpenMS::IsotopeDistribution& id) const noexcept
    {
      std::size_t seed = OpenMS::hash_int(id.size());
      for (const auto& peak : id)
      {
        OpenMS::hash_combine(seed, std::hash<OpenMS::Peak1D>{}(peak));
      }
      return seed;
    }
  };
} // namespace std