isobarAmplitude.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:
//      virtual base class for isobar decay amplitude independent of formalism
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef ISOBARAMPLITUDE_H
#define ISOBARAMPLITUDE_H


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

#include "isobarDecayTopology.h"


namespace rpwa {  


        class isobarAmplitude;
        typedef boost::shared_ptr<rpwa::isobarAmplitude> isobarAmplitudePtr;


        class isobarAmplitude {
  
        public:
      
                isobarAmplitude();
                isobarAmplitude(const isobarDecayTopologyPtr& decay);
                virtual ~isobarAmplitude();

                const isobarDecayTopologyPtr& decayTopology   () const { return _decay; }              
                void                          setDecayTopology(const isobarDecayTopologyPtr& decay);   

                virtual void init();  

                bool reflectivityBasis    () const { return _useReflectivityBasis; }  
                bool boseSymmetrization   () const { return _boseSymmetrize;       }  
                bool isospinSymmetrization() const { return _isospinSymmetrize;    }  
                void enableReflectivityBasis    (const bool flag = true) { _useReflectivityBasis = flag; }  
                void enableBoseSymmetrization   (const bool flag = true) { _boseSymmetrize       = flag; }  
                void enableIsospinSymmetrization(const bool flag = true) { _isospinSymmetrize    = flag; }  

                bool doSpaceInversion() const { return _doSpaceInversion; }  
                bool doReflection    () const { return _doReflection;     }  
                void enableSpaceInversion(const bool flag = true) { _doSpaceInversion = flag; }  
                void enableReflection    (const bool flag = true) { _doReflection     = flag; }  

                static TLorentzRotation gjTransform(const TLorentzVector& beamLv,
                                                    const TLorentzVector& XLv);  
    
                std::complex<double> amplitude()   const;                         
                std::complex<double> operator ()() const { return amplitude(); }  

                virtual std::string   name           ()                  const { return "isobarAmplitude"; }
                virtual std::ostream& printParameters(std::ostream& out) const;  
                virtual std::ostream& print          (std::ostream& out) const;  
    
                static bool debug() { return _debug; }                             
                static void setDebug(const bool debug = true) { _debug = debug; }  
    

        protected:

                void spaceInvertDecay() const;  
                void reflectDecay    () const;  

                virtual void transformDaughters() const = 0;  

                virtual std::complex<double> twoBodyDecayAmplitude
                (const isobarDecayVertexPtr& vertex,
                 const bool                  topVertex) const = 0;  
    
                virtual std::complex<double> twoBodyDecayAmplitudeSum
                (const isobarDecayVertexPtr& vertex,
                 const bool                  topVertex = false) const;  

                virtual std::complex<double> symTermAmp(const std::vector<unsigned int>& fsPartPermMap) const;  

                virtual bool initSymTermMaps();

                isobarDecayTopologyPtr  _decay;                 
                bool                    _useReflectivityBasis;  
                bool                    _boseSymmetrize;        
                bool                    _isospinSymmetrize;     
                bool                    _doSpaceInversion;      
                bool                    _doReflection;          
                std::vector<symTermMap> _symTermMaps;           
    
                static bool _debug;  
    
        };
  

        inline
        std::ostream&
        operator <<(std::ostream&          out,
                    const isobarAmplitude& amp)
        {
                return amp.print(out);
        }
  
  
} // namespace rpwa


#endif  // ISOBARAMPLITUDE_H