amplitude/particle.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:
//      container class for all particle related external information
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef PARTICLE_H
#define PARTICLE_H


#include <string>

#include <boost/shared_ptr.hpp>

#include "TVector3.h"
#include "TLorentzVector.h"
#include "TLorentzRotation.h"

#include "conversionUtils.hpp"
#include "particleProperties.h"


namespace rpwa {

        class particle;
        typedef boost::shared_ptr<particle> particlePtr;


        class particle : public particleProperties {

        public:

                particle();
                particle(const particle&           part);
                particle(const particleProperties& partProp,
                         const int                 index    = -1,
                         const int                 spinProj = 0,
                         const int                 refl     = 0,
                         const TVector3&           momentum = TVector3());
                particle(const std::string&        partName,
                         const bool                requirePartInTable = true,
                         const int                 index              = -1,
                         const int                 spinProj           = 0,
                         const int                 refl               = 0,
                         const TVector3&           momentum           = TVector3());
                particle(const std::string&        partName,
                         const int                 isospin,
                         const int                 G,
                         const int                 J,
                         const int                 P,
                         const int                 C,
                         const int                 spinProj,
                         const int                 refl  = 0,
                         const int                 index = -1);
                virtual ~particle();

                particle& operator =(const particle& part);
                particlePtr clone() const { return particlePtr(doClone()); }  

                int                   spinProj    () const { return _spinProj;                   }  
                TVector3              momentum    () const { return _lzVec.Vect();               }  
                const TLorentzVector& lzVec       () const { return _lzVec;                      }  
                int                   index       () const { return _index;                      }  
                int                   reflectivity() const { return _refl;                       }  

                void setSpinProj    (const int             spinProj) { _spinProj = spinProj;                                                          }  
                void setMomentum    (const TVector3&       momentum) { _lzVec    = TLorentzVector(momentum, sqrt(momentum.Mag2() + mass() * mass())); }  
                void setLzVec       (const TLorentzVector& lzVec   ) { _lzVec    = lzVec;                                                             }  
                void setIndex       (const int             index   ) { _index    = index;                                                             }  
                void setReflectivity(const int             refl    ) { _refl     = signum(refl);                                                      }  

                void setProperties(const particleProperties& prop);  

                const TLorentzVector& transform(const TLorentzRotation& L)     { return _lzVec.Transform(L); }  
                const TLorentzVector& transform(const TVector3&         boost)  
                {
                        _lzVec.Boost(boost);
                        return _lzVec;
                }

                virtual std::string qnSummary() const;  

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

                virtual std::string label() const;  

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


        protected:

                virtual particle* doClone() const;  

                virtual bool isEqualTo(const particleProperties& partProp) const;  

        private:

                int            _spinProj;  
                TLorentzVector _lzVec;     
                int            _index;     
                int            _refl;      

                static bool _debug;  

        };


        inline
        particlePtr
        createParticle(const particle& part)
        {
                particlePtr partCopy(new particle(part));
                return partCopy;
        }


        inline
        particlePtr
        createParticle(const particleProperties& partProp,
                       const int                 index    = -1,
                       const int                 spinProj = 0,
                       const int                 refl     = 0,
                       const TVector3&           momentum = TVector3())
        {
                particlePtr part(new particle(partProp, index, spinProj, refl, momentum));
                return part;
        }


        inline
        particlePtr
        createParticle(const std::string& partName,
                       const bool         requirePartInTable = true,
                       const int          index              = -1,
                       const int          spinProj           = 0,
                       const int          refl               = 0,
                       const TVector3&    momentum           = TVector3())
        {
                particlePtr part(new particle(partName, requirePartInTable, index, spinProj, refl, momentum));
                return part;
        }


        inline
        particlePtr
        createParticle(const std::string& partName,
                       const int          isospin,
                       const int          G,
                       const int          J,
                       const int          P,
                       const int          C,
                       const int          spinProj,
                       const int          refl  = 0,
                       const int          index = -1)
        {
                particlePtr part(new particle(partName, isospin, G, J, P, C, spinProj, refl, index));
                return part;
        }


        // predicate for ascending sort
        inline
        bool
        compareIndicesAsc(const particlePtr& a,
                          const particlePtr& b)
        {
                if (not a or not b) {
                        printWarn << "null pointer to particle. result undefined." << std::endl;
                        return false;
                }
                return a->index() < b->index();
        }


        // predicate for descending sort
        inline
        bool
        compareIndicesDesc(const particlePtr& a,
                           const particlePtr& b)
        {
                if (not a or not b) {
                        printWarn << "null pointer to particle. result undefined." << std::endl;
                        return false;
                }
                return a->index() > b->index();
        }


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


}  // namespace rpwa


#endif  // PARTICLE_H