FeatureFinderAlgorithmPickedHelperStructs.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-2012.
//
// 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: Stephan Aiche $
// $Authors: Marc Sturm, Stephan Aiche $
// --------------------------------------------------------------------------

#ifndef OPENMS_TRANSFORMATIONS_FEATUREFINDER_FEATUREFINDERALGORITHMPICKEDHELPERSTRUCTS_H
#define OPENMS_TRANSFORMATIONS_FEATUREFINDER_FEATUREFINDERALGORITHMPICKEDHELPERSTRUCTS_H

#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/Exception.h>

#include <OpenMS/DATASTRUCTURES/String.h>
#include <OpenMS/DATASTRUCTURES/StringList.h>
#include <OpenMS/DATASTRUCTURES/ConvexHull2D.h>

#include <vector>

namespace OpenMS
{

  struct OPENMS_DLLAPI FeatureFinderAlgorithmPickedHelperStructs
  {

    struct OPENMS_DLLAPI Seed
    {
      Size spectrum;
      Size peak;
      Real intensity;

      bool operator<(const Seed & rhs) const
      {
        return intensity < rhs.intensity;
      }

    };

    template <class PeakType>
    struct MassTrace
    {
      const PeakType * max_peak;
      DoubleReal max_rt;

      DoubleReal theoretical_int;

      std::vector<std::pair<DoubleReal, const PeakType *> > peaks;

      ConvexHull2D getConvexhull() const
      {
        ConvexHull2D::PointArrayType hull_points(peaks.size());
        for (Size i = 0; i < peaks.size(); ++i)
        {
          hull_points[i][0] = peaks[i].first;
          hull_points[i][1] = peaks[i].second->getMZ();
        }
        ConvexHull2D hull;
        hull.addPoints(hull_points);
        return hull;
      }

      void updateMaximum()
      {
        if (peaks.empty()) return;

        max_rt = peaks.begin()->first;
        max_peak = peaks.begin()->second;

        for (Size i = 1; i < peaks.size(); ++i)
        {
          if (peaks[i].second->getIntensity() > max_peak->getIntensity())
          {
            max_rt = peaks[i].first;
            max_peak = peaks[i].second;
          }
        }
      }

      DoubleReal getAvgMZ() const
      {
        DoubleReal sum = 0.0;
        DoubleReal intensities = 0.0;
        for (Size i = 0; i < peaks.size(); ++i)
        {
          sum += peaks[i].second->getMZ() * peaks[i].second->getIntensity();
          intensities += peaks[i].second->getIntensity();
        }
        return sum / intensities;
      }

      bool isValid() const
      {
        return peaks.size() >= 3;
      }

    };

    template <class PeakType>
    struct MassTraces :
      public std::vector<MassTrace<PeakType> >
    {
      MassTraces() :
        max_trace(0)
      {
      }

      Size getPeakCount() const
      {
        Size sum = 0;
        for (Size i = 0; i < this->size(); ++i)
        {
          sum += this->at(i).peaks.size();
        }
        return sum;
      }

      bool isValid(DoubleReal seed_mz, DoubleReal trace_tolerance)
      {
        //Abort if too few traces were found
        if (this->size() < 2) return false;

        //Abort if the seed was removed
        for (Size j = 0; j < this->size(); ++j)
        {
          if (std::fabs(seed_mz - this->at(j).getAvgMZ()) <= trace_tolerance)
          {
            return true;
          }
        }
        return false;
      }

      Size getTheoreticalmaxPosition() const
      {
        if (!this->size())
        {
          throw Exception::Precondition(__FILE__, __LINE__, __PRETTY_FUNCTION__, "There must be at least one trace to determine the theoretical maximum trace!");
        }

        Size max = 0;
        DoubleReal max_int = this->at(0).theoretical_int;
        for (Size i = 1; i < this->size(); ++i)
        {
          if (this->at(i).theoretical_int > max_int)
          {
            max_int = this->at(i).theoretical_int;
            max = i;
          }
        }
        return max;
      }

      void updateBaseline()
      {
        if (this->size() == 0)
        {
          baseline = 0.0;
          return;
        }
        bool first = true;
        for (Size i = 0; i < this->size(); ++i)
        {
          for (Size j = 0; j < this->at(i).peaks.size(); ++j)
          {
            if (first)
            {
              baseline = this->at(i).peaks[j].second->getIntensity();
              first = false;
            }
            if (this->at(i).peaks[j].second->getIntensity() < baseline)
            {
              baseline = this->at(i).peaks[j].second->getIntensity();
            }
          }
        }
      }

      std::pair<DoubleReal, DoubleReal> getRTBounds() const
      {
        if (!this->size())
        {
          throw Exception::Precondition(__FILE__, __LINE__, __PRETTY_FUNCTION__, "There must be at least one trace to determine the RT boundaries!");
        }

        DoubleReal min = std::numeric_limits<DoubleReal>::max();
        DoubleReal max = -std::numeric_limits<DoubleReal>::max();
        //Abort if the seed was removed
        for (Size i = 0; i < this->size(); ++i)
        {
          for (Size j = 0; j < this->at(i).peaks.size(); ++j)
          {
            DoubleReal rt = this->at(i).peaks[j].first;
            if (rt > max) max = rt;
            if (rt < min) min = rt;
          }
        }
        return std::make_pair(min, max);
      }

      Size max_trace;
      DoubleReal baseline;
    };

    struct OPENMS_DLLAPI TheoreticalIsotopePattern
    {
      std::vector<DoubleReal> intensity;
      Size optional_begin;
      Size optional_end;
      DoubleReal max;
      Size trimmed_left;
      Size size() const
      {
        return intensity.size();
      }

    };

    struct OPENMS_DLLAPI IsotopePattern
    {
      std::vector<SignedSize> peak;
      std::vector<Size> spectrum;
      std::vector<DoubleReal> intensity;
      std::vector<DoubleReal> mz_score;
      std::vector<DoubleReal> theoretical_mz;
      TheoreticalIsotopePattern theoretical_pattern;

      IsotopePattern(Size size) :
        peak(size, -1),
        spectrum(size),
        intensity(size),
        mz_score(size),
        theoretical_mz(size)
      {
      }

    };

  };
}

#endif // #ifndef OPENMS_TRANSFORMATIONS_FEATUREFINDER_FEATUREFINDERALGORITHMPICKEDHELPERSTRUCTS_H