IMSIsotopeDistribution.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Anton Pervukhin <Anton.Pervukhin@CeBiTec.Uni-Bielefeld.DE> $
// --------------------------------------------------------------------------
//
 
#pragma once
 
#include <algorithm> // std::min
#include <vector>
#include <iosfwd>
 
#include <OpenMS/config.h>
 
namespace OpenMS
{
 
  namespace ims
  {
 
    class OPENMS_DLLAPI IMSIsotopeDistribution
    {
 
public:
      typedef double mass_type;
 
      typedef double abundance_type;
 
      typedef unsigned int nominal_mass_type;
 
      struct Peak
      {
        Peak(mass_type local_mass = 0.0, abundance_type local_abundance = 0.0) :
          mass(local_mass), abundance(local_abundance)
        {}
 
        bool operator==(const Peak & peak) const
        {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wfloat-equal"
          return peak.mass == mass && peak.abundance == abundance;
#pragma clang diagnostic pop
        }
 
        mass_type mass;
        abundance_type abundance;
      };
 
      typedef Peak peak_type;
 
      typedef std::vector<peak_type> peaks_container;
 
      typedef peaks_container::iterator peaks_iterator;
 
      typedef peaks_container::const_iterator const_peaks_iterator;
 
      typedef peaks_container::size_type size_type;
 
      typedef std::vector<mass_type> masses_container;
 
      typedef masses_container::iterator masses_iterator;
 
      typedef masses_container::const_iterator const_masses_iterator;
 
      typedef std::vector<abundance_type> abundances_container;
 
      typedef abundances_container::iterator abundances_iterator;
 
      typedef abundances_container::const_iterator const_abundances_iterator;
 
      static abundance_type ABUNDANCES_SUM_ERROR;
 
      static size_type SIZE;
 
      explicit IMSIsotopeDistribution(nominal_mass_type nominalMass = 0) :
        nominal_mass_(nominalMass)
      {}
 
      explicit IMSIsotopeDistribution(mass_type mass) :
        nominal_mass_(0)
      {
        peaks_.push_back(peaks_container::value_type(mass, 1.0));
      }
 
      IMSIsotopeDistribution(const peaks_container & peaks,
                             nominal_mass_type nominalMass = 0) :
        peaks_(peaks),
        nominal_mass_(nominalMass)
      {}
 
      IMSIsotopeDistribution(const IMSIsotopeDistribution & distribution) :
        peaks_(distribution.peaks_),
        nominal_mass_(distribution.nominal_mass_)
      {}
 
      ~IMSIsotopeDistribution()
      {}
 
      size_type size() const { return std::min(peaks_.size(), SIZE); }
 
      IMSIsotopeDistribution & operator=(
        const IMSIsotopeDistribution & distribution);
 
      bool operator==(const IMSIsotopeDistribution & distribution) const;
 
      bool operator!=(const IMSIsotopeDistribution & distribution) const;
 
      IMSIsotopeDistribution & operator*=(
        const IMSIsotopeDistribution & distribution);
 
      IMSIsotopeDistribution & operator*=(unsigned int pow);
 
      mass_type getMass(size_type i) const
      {
        return peaks_[i].mass + nominal_mass_ + i;
      }
 
      abundance_type getAbundance(size_type i) const
      {
        return peaks_[i].abundance;
      }
 
      mass_type getAverageMass() const;
 
      nominal_mass_type getNominalMass() const { return nominal_mass_; }
 
      void setNominalMass(nominal_mass_type nominalMass)
      {
        this->nominal_mass_ = nominalMass;
      }
 
      masses_container getMasses() const;
 
      abundances_container getAbundances() const;
 
      void normalize();
 
      bool empty() const { return peaks_.empty(); }
 
private:
      peaks_container peaks_;
 
      nominal_mass_type nominal_mass_;
 
      void setMinimumSize_();
    };
 
    OPENMS_DLLAPI std::ostream & operator<<(std::ostream & os,
                                            const IMSIsotopeDistribution & distribution);
 
  } // namespace ims
} // namespace OpenMS