IMSIsotopeDistribution.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2020.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Anton Pervukhin <Anton.Pervukhin@CeBiTec.Uni-Bielefeld.DE> $
// --------------------------------------------------------------------------
//
 
#pragma once
 
#include <vector>
#include <iosfwd>
#include <algorithm>
 
#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