isobarDecayVertex.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:
//      class that describes decay vertex of isobar into two particles
//      the isobar -> particle1 + particle 2 vertex has exactly one
//      incoming parent and two outgoing daughter particle
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef ISOBARDECAYVERTEX_H
#define ISOBARDECAYVERTEX_H


#include "interactionVertex.h"
#include "massDependence.h"


namespace rpwa {


        class isobarDecayVertex;
        typedef boost::shared_ptr<isobarDecayVertex> isobarDecayVertexPtr;


        class isobarDecayVertex : public interactionVertex {

        public:
  
                isobarDecayVertex(const particlePtr&       parent,
                                  const particlePtr&       daughter1,
                                  const particlePtr&       daughter2,
                                  const unsigned int       L       = 0,
                                  const unsigned int       S       = 0,
                                  const massDependencePtr& massDep = massDependencePtr());  
                isobarDecayVertex(const isobarDecayVertex& vert);
                virtual ~isobarDecayVertex();
                
                isobarDecayVertex& operator =(const isobarDecayVertex& vert);
                isobarDecayVertexPtr clone(const bool cloneInParticles  = false,
                                           const bool cloneOutParticles = false) const  
                { return isobarDecayVertexPtr(doClone(cloneInParticles, cloneOutParticles)); }

                virtual bool addInParticle (const particlePtr&);  
                virtual bool addOutParticle(const particlePtr&);  

                // isobar decay specific accessors
                inline particlePtr&       parent   ()       { return inParticles ()[0]; }  
                inline particlePtr&       daughter1()       { return outParticles()[0]; }  
                inline particlePtr&       daughter2()       { return outParticles()[1]; }  
                inline const particlePtr& parent   () const { return inParticles ()[0]; }  
                inline const particlePtr& daughter1() const { return outParticles()[0]; }  
                inline const particlePtr& daughter2() const { return outParticles()[1]; }  

                const TLorentzVector& calcParentLzVec();  

                int calcParentCharge   ();  
                int calcParentBaryonNmb();  
    
                inline unsigned int L() const { return _L; }  
                inline unsigned int S() const { return _S; }  

                inline void setL(const unsigned int L) { _L = L; }  
                inline void setS(const unsigned int S) { _S = S; }  

                inline std::complex<double>     massDepAmplitude() const { return _massDep->amp(*this); }  
                inline const massDependencePtr& massDependence  () const { return _massDep;             }  
                inline void setMassDependence(const massDependencePtr& massDep) { _massDep = massDep; }    

                bool checkConsistency();  

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

                virtual std::string name() const { return "isobarDecayVertex"; }  

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


        protected:

                virtual isobarDecayVertex* doClone(const bool cloneInParticles,
                                                   const bool cloneOutParticles) const;  

                virtual bool isEqualTo(const interactionVertex& vert) const;  

        private:

                bool checkMultiplicativeQn(const int          parentQn,
                                           const int          daughter1Qn,
                                           const int          daughter2Qn,
                                           const std::string& qnName = "");  
                bool checkAdditiveQn      (const int          parentQn,
                                           const int          daughter1Qn,
                                           const int          daughter2Qn,
                                           const std::string& qnName = "");  
    
                unsigned int _L;  
                unsigned int _S;  

                massDependencePtr _massDep;  

                static bool _debug;  

        };


        inline
        isobarDecayVertexPtr
        createIsobarDecayVertex(const particlePtr&       parent,
                                const particlePtr&       daughter1,
                                const particlePtr&       daughter2,
                                const unsigned int       L       = 0,
                                const unsigned int       S       = 0,
                                const massDependencePtr& massDep = massDependencePtr())
        {
                isobarDecayVertexPtr vert(new isobarDecayVertex(parent, daughter1, daughter2, L, S, massDep));
                return vert;
        }


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


}  // namespace rpwa


#endif  // ISOBARDECAYVERTEX_H