ms_fragmentvector.hpp

/*
##############################################################################
# File: ms_fragmentvector.hpp                                                #
# Mascot Parser toolkit                                                      #
# Encapsulates a list (vector) of single fragment ions                       #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 1998-2006 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
#    $Source: parser/inc/ms_fragmentvector.hpp $
#    $Author: villek@matrixscience.com $ 
#      $Date: 2018-07-30 16:23:53 +0100 $ 
#  $Revision: 1b450440f9c97e1e41d0fc6016a27d68951d4532 | MSPARSER_REL_2_8_1-0-gea32989045 $
##############################################################################
*/

#if !defined(ms_fragmentvector_INCLUDED_)
#define ms_fragmentvector_INCLUDED_


// Includes from the standard template library
#include <string>
#include <set>
#include <vector>
#include <map>


namespace matrix_science {
     class ms_mascotresfile;



    class MS_MASCOTRESFILE_API ms_fragmentvector
    {
    public:


        enum MATCH_PEAKS 
        { 

            MATCH_MOST_INTENSE_PEAK  = 0x0000, 
            MATCH_CLOSEST_PEAK       = 0x0001  
        };

        enum TOLERANCE_UNIT
        {
            TOLERANCE_DALTON,
            TOLERANCE_MMU,
            TOLERANCE_PERCENT,
            TOLERANCE_PPM
        };

        ms_fragmentvector();

        ms_fragmentvector(const ms_fragmentvector& src);

        virtual ~ms_fragmentvector();

        void copyFrom(const ms_fragmentvector* right);

#ifndef SWIG

        ms_fragmentvector& operator=(const ms_fragmentvector& right);
#endif

        int getNumberOfFragments() const;

        void clearFragments();

        void appendFragment(const ms_fragment * item);

        const ms_fragment * getFragmentByNumber(const unsigned int numFrag) const;

        typedef std::vector<ms_fragment> frag_vector;

#if !defined(SWIGJAVA) && !defined(SWIGCSHARP)

        frag_vector * getVector();
#endif        

        const frag_vector * getVector() const;

        bool addExperimentalData(const std::string & peakList, 
                                 const int           numPeaks, 
                                 const double        tolerance, 
                                 const std::string & toleranceUnits,
                                 const bool          updateMatchList = true);

        bool addExperimentalData(const ms_mascotresfile * resfile,
                                 const int query,
                                 const int flags = MATCH_MOST_INTENSE_PEAK,
                                 const int peaksUsedFromIons1 = -1,
                                 const int peaksUsedFromIons2 = -1,
                                 const int peaksUsedFromIons3 = -1);

        typedef std::map<double, double> peaklist_t;  // Mass, intensity

        bool addExperimentalData(const peaklist_t &  peakList, 
                                 const double        tolerance, 
                                 const std::string & toleranceUnits,
                                 const bool          updateMatchList = true);

        static void getMassesWithinTolerance(const double & fragmentMass, const double & fragmentToleranceValue, const TOLERANCE_UNIT & fragmentToleranceUnit,
                                             double & minMass, double & maxMass);
        
    private:
        frag_vector  entries_;
        peaklist_t experimentalData_;
        void matchFragments();
        double   matchingTol_; 
        std::string matchingTolUnits_;
    }; // class ms_fragmentvector // end of mass_calculation_group
} // matrix_science

#endif // !defined(ms_fragmentvector_INCLUDED_)