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-2018.
//
// 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 <ostream>
#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