amplitudeTreeLeaf.h

Go to the documentation of this file.

//
//    Copyright 2010
//
//    This file is part of rootpwa
//
//    rootpwa is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    rootpwa is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with rootpwa. If not, see <http://www.gnu.org/licenses/>.
//
//-------------------------------------------------------------------------
// File and Version Information:
// $Rev::                             $: revision of last commit
// $Author::                          $: author of last commit
// $Date::                            $: date of last commit
//
// Description:
//      TTree leaf storage class for amplitude information
//
//      class allows to define named subamplitudes that are summed
//      incoherently in the intensity formula
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef AMPLITUDETREELEAF_H
#define AMPLITUDETREELEAF_H


#include <vector>
#include <map>
#include <complex>

#include "TObject.h"


namespace rpwa {


        class amplitudeTreeLeaf : public TObject {


                typedef std::map<std::string, unsigned int>::const_iterator labelToIndexMapIterator;


        public:

                amplitudeTreeLeaf();
                virtual ~amplitudeTreeLeaf();

                void clear();  

                amplitudeTreeLeaf& operator =(const amplitudeTreeLeaf& amp);

                friend bool operator ==(const amplitudeTreeLeaf& lhsAmp,
                                        const amplitudeTreeLeaf& rhsAmp);

                // arithmetic operators for integrals
                amplitudeTreeLeaf& operator +=(const amplitudeTreeLeaf& amp);  
                amplitudeTreeLeaf& operator -=(const amplitudeTreeLeaf& amp);  

                template<typename T>
                amplitudeTreeLeaf& operator *=(const T& factor);  
                template<typename T>
                amplitudeTreeLeaf& operator /=(const T& factor);  
                
                // accessors
                unsigned int nmbIncohSubAmps() const { return _incohSubAmps.size(); }  

                bool               containsIncohSubAmp(const std::string& subAmpLabel) const; 
                unsigned int       incohSubAmpIndex   (const std::string& subAmpLabel) const;
                const std::string& incohSubAmpName    (const unsigned int subAmpIndex) const;

                const std::complex<double>& incohSubAmp(const unsigned int index = 0  ) const
                { return _incohSubAmps[index];                         }  
                const std::complex<double>& incohSubAmp(const std::string& subAmpLabel) const
                { return _incohSubAmps[incohSubAmpIndex(subAmpLabel)]; }  

                const std::complex<double>& amp() const { return incohSubAmp(0);       }  

                void defineIncohSubAmps(const std::vector<std::string>& subAmpLabels);  

                void setIncohSubAmp(const std::complex<double>& amp,
                                    const unsigned int          index = 0) { _incohSubAmps[index] = amp; }  

                void setAmp (const std::complex<double>& amp) { setIncohSubAmp(amp, 0); }  

                std::ostream& print(std::ostream& out) const;  

                static bool debug() { return _debug; }                             
                static void setDebug(const bool debug = true) { _debug = debug; }  


        private:

                void rebuildSubAmpLabelMap();  

                static bool _debug;  

                std::vector<std::complex<double> >  _incohSubAmps;       
                std::vector<std::string>            _incohSubAmpLabels;  
                std::map<std::string, unsigned int> _labelToIndexMap;    


#ifdef USE_STD_COMPLEX_TREE_LEAFS
                ClassDef(amplitudeTreeLeaf,1)
#endif

        };


        // comparison operators
        inline
        bool
        operator ==(const amplitudeTreeLeaf& lhsAmp,
                    const amplitudeTreeLeaf& rhsAmp)
        {
                const unsigned int nmbSubAmps = lhsAmp.nmbIncohSubAmps();
                if (nmbSubAmps != lhsAmp.nmbIncohSubAmps())
                        return false;
                for (unsigned int i = 0; i < nmbSubAmps; ++i)
                        if (lhsAmp.incohSubAmp(i) != rhsAmp.incohSubAmp(i))
                                return false;
                return true;
        }

        inline
        bool
        operator !=(const amplitudeTreeLeaf& lhsAmp,
                    const amplitudeTreeLeaf& rhsAmp)
        {
                return not(lhsAmp == rhsAmp);
        }


        // arithmetic operators for integrals
        template<typename T>
        inline
        amplitudeTreeLeaf&
        amplitudeTreeLeaf::operator *=(const T& factor)
        {
                for (unsigned int i = 0; i < nmbIncohSubAmps(); ++i)
                        _incohSubAmps[i] *= factor;
                return *this;
        }


        template<typename T>
        inline
        amplitudeTreeLeaf&
        amplitudeTreeLeaf::operator /=(const T& factor)
        {
                for (unsigned int i = 0; i < nmbIncohSubAmps(); ++i)
                        _incohSubAmps[i] /= factor;
                return *this;
        }


        inline
        amplitudeTreeLeaf
        operator +(const amplitudeTreeLeaf& ampA,
                   const amplitudeTreeLeaf& ampB)
        {
                amplitudeTreeLeaf result = ampA;
                result += ampB;
                return result;
        }

        inline
        amplitudeTreeLeaf
        operator -(const amplitudeTreeLeaf& ampA,
                   const amplitudeTreeLeaf& ampB)
        {
                amplitudeTreeLeaf result = ampA;
                result -= ampB;
                return result;
        }

        template<typename T>
        inline
        amplitudeTreeLeaf
        operator *(const amplitudeTreeLeaf& amp,
                   const T&                 factor)
        {
                amplitudeTreeLeaf result = amp;
                result *= factor;
                return result;
        }

        template<typename T>
        inline
        amplitudeTreeLeaf
        operator *(const T&                 factor,
                   const amplitudeTreeLeaf& amp)
        {
                return amp * factor;
        }

        template<typename T>
        inline
        amplitudeTreeLeaf
        operator /(const amplitudeTreeLeaf& amp,
                   const T&                 factor)
        {
                amplitudeTreeLeaf result = amp;
                result /= factor;
                return result;
        }


        inline
        std::ostream&
        operator <<(std::ostream&            out,
                    const amplitudeTreeLeaf& amp)
        {
                return amp.print(out);
        }


}  // namespace rpwa


#endif  // AMPLITUDETREELEAF_H