Spectrum.h

Go to the documentation of this file.

#ifndef __KOME_OBJECTS_SPECTRUM_H__
#define __KOME_OBJECTS_SPECTRUM_H__


#include <string>
#include <boost/optional.hpp>


namespace kome {
    namespace objects {

        class Sample;
        class DataGroupNode;

        class DATA_OBJECTS_CLASS Spectrum {
        public:
            Spectrum( Sample* sample, const char* name );

            virtual ~Spectrum();

        public:
            typedef enum {
                POLARITY_UNKNOWN = 0,
                POLARITY_POSITIVE = 1,
                POLARITY_NEGATIVE = 2
            } Polarity;

        protected:
            struct PrecursorInfo {
                int stage;
                double precursor;
                double intensity;
            };

        private:
            Sample* m_sample;

            std::string m_name;

            Spectrum* m_parentSpec;

            std::vector< Spectrum* > m_children;

            bool m_chrom;

            DataGroupNode* m_group;

            struct {
                double start;
                double end;
            } m_rt;

            std::string m_icon;

            std::string m_specType;

            std::string m_title;

            boost::optional< double > m_minX;

            boost::optional< double > m_maxX;

            boost::optional< double > m_tic;

            boost::optional< double > m_bpi;

            double m_bpm;

            int m_msStage;

            std::vector< PrecursorInfo > m_precursor;

            int m_charge;

            int m_scanNumber;

            Polarity m_polarity;

            bool m_centroidMode;

            double m_resolution;

            std::string m_collisionEnergy;

            bool m_visible;

            kome::core::Properties m_props;

            kome::core::Properties m_userProps;

            bool m_autoZeroPoints;

            // >>>>>> @Date:2013/07/11  <Add>   A.Ozaki

            std::string m_strSpotId;

            // <<<<<< @Date:2013/07/11  <Add>   A.Ozaki

        protected:
            Spectrum* m_orgSpec;
            
            bool m_op;

        protected:
            static std::vector< std::string > m_commonProps;
            
            int m_specId;

        public:
            void setId( int id );

            int getId();

        public:
            void setOperationFlag( const bool op ){ m_op = op; }

            bool getOperationFlag(){ return m_op; }
        public:
            Sample* getSample();

            void setName( const char* name );

            const char* getName();

            void setRt( const double rt );

            void setRt( const double startRt, const double endRt );

            void setStartRt( const double rt );

            void setEndRt( const double rt );

            double getRt();

            double getStartRt();

            double getEndRt();

            void setSpecType( const char* type );

            const char* getSpecType();

            void setTitle( const char* title );

            const char* getTitle();

            void setIcon( const char* icon );

            const char* getIcon();

            kome::core::XYData* getXYData();

            void deleteXYData();

            void getXYData( kome::core::XYData* const xyData, const bool op );

            void getXYData( kome::core::XYData* const xyData, const double minX, const double maxX, const bool zero );

            void setXRange( const double minX, const double maxX );

            void setMinX( const double minX );

            double getMinX();

            void setMaxX( const double maxX );

            double getMaxX();

            void setTotalIntensity( const double intensity );

            double getTotalIntensity( const double minX = -1.0, const double maxX = -1.0 );

            void setMaxIntensity( const double intensity );

            double getMaxIntensity( const double minX = -1.0, const double maxX = -1.0 );

            void setBasePeakMass( const double mass );

            double getBasePeakMass();

            void setMsStage( const int stage );

            int getMsStage();

            void setPrecursor( const int stage, const double precursor );

            void setPrecursor( const double precursor );

            double getPrecursor( const int stage );

            double getPrecursor();

            void setPrecursorIntensity( const int stage, const double intensity );

            void setPrecursorIntensity( const double intensity );

            double getPrecursorIntensity( const int stage );

            double getPrecursorIntensity();

            void setPrecursorCharge( const int charge );

            int getPrecursorCharge();

            void setParentSpectrum( Spectrum* const parent );

            Spectrum* getParentSpectrum();

            void getChildSpectra( std::vector< Spectrum* >& children );

            void setHasChromatogram( const bool chromatogram );

            bool hasChromatogram();

            void setGroup( DataGroupNode* group );

            DataGroupNode* getGroup();

            void setScanNumber( const int scan );

            int getScanNumber();

            void setPolarity( Polarity polarity );

            Polarity getPolarity();

            void setCentroidMode( const bool centroidMode );

            bool isCentroidMode();

            void setResolution( const double resolution );

            double getResolution();

            void setCollisionEnergy( const char* collisionEnergy );

            const char* getCollisionEnergy();

            void setVisible( const bool visible );

             bool isVisible();

             void setAutoZeroPoints( const bool autoZero );

             bool isAutoZeroPoints();

            kome::core::Properties& getProperties();

            kome::core::Properties& getUserProperties();

            void setOrgSpectrum( Spectrum* spec );

            Spectrum* getOrgSpectrum();

            void getProperties( kome::core::Properties& properties );

            void getUserProperties( kome::core::Properties& userProperties );

            // >>>>>> @Date:2013/07/16  <Add>   A.Ozaki
            //
            void    setSpotId( const char *pcSpotId );

            const char  *getSpotId( void );
            //
            // <<<<<< @Date:2013/07/16  <Add>   A.Ozaki

        public:
            static bool isCommonProperty( const char* key );

        protected:
            virtual void onGetXYData( kome::core::XYData* const xyData, const double minX, const double maxX ) = 0;

            virtual void onGetXRange( double* minX, double* maxX ) = 0;

            virtual double onGetTotalIntensity( const double minX, const double maxX ) = 0;

            virtual double onGetMaxIntensity( const double minX, const double maxX ) = 0;

            // >>>>>> @Date:2013/07/16  <Add>   A.Ozaki
            //
            virtual void    onSetRequestLoadData( void );
            virtual void    onResetRequestLoadData( void );
            
            virtual bool    onIsRequestLoadData( void );

            virtual void    onSetFirstAccess( void );

            virtual void    onResetFirstAccess( void );
            
            virtual bool    onIsFirstAccess( void );
            
            virtual bool    onLoadData( void );

            bool    firstAccessProcess( void );

        public:
             void   setRequestLoadData( void );

             void   resetRequestLoadData( void );
            
            bool    isRequestLoadData( void );

            void    setFirstAccess( void );

            void    resetFirstAccess( void );
            
            bool    isFirstAccess( void );
            
            bool    loadData( void );
            //
            // <<<<<< @Date:2013/07/16  <Add>   A.Ozaki

        };
    }
}

#endif  // __KOME_OBJECTS_SPECTRUM_H__