diffractiveDissVertex.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 production vertex in diffractive
//      dissociation the beam-Reggeon-X vertex has exactly one
//      incoming beam and one outgoing particle (X), which
//      unambiguously defines the Reggeon kinematics; if the target
//      momentum is not specified, a fixed target is assumed; if the
//      recoil particle is not specified, elastic scattering is
//      assumed
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef DIFFRACTIVEDISSVERTEX_H
#define DIFFRACTIVEDISSVERTEX_H


#include <boost/shared_ptr.hpp>

#include "productionVertex.h"


class TClonesArray;


namespace rpwa {


        class diffractiveDissVertex;
        typedef boost::shared_ptr<diffractiveDissVertex> diffractiveDissVertexPtr;


        class diffractiveDissVertex : public productionVertex {

        public:
  
                diffractiveDissVertex(const particlePtr& beam,
                                      const particlePtr& target,
                                      const particlePtr& XParticle,
                                      const particlePtr& recoil = particlePtr());  
                diffractiveDissVertex(const diffractiveDissVertex& vert);
                virtual ~diffractiveDissVertex();
                
                diffractiveDissVertex& operator =(const diffractiveDissVertex& vert);
                diffractiveDissVertexPtr clone(const bool cloneInParticles  = false,
                                               const bool cloneOutParticles = false) const  
                { return diffractiveDissVertexPtr(doClone(cloneInParticles, cloneOutParticles)); }

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

                // production specific accessors
                virtual const TLorentzVector& referenceLzVec() const { return beam()->lzVec();   }  
                virtual const particlePtr&    XParticle     () const { return outParticles()[0]; }  

                virtual std::complex<double> productionAmp() const;  

                virtual void setXFlavorQN();  

                // diffractive dissociation specific accessors
                inline const particlePtr& beam  () const { return inParticles ()[0]; }  
                inline const particlePtr& target() const { return inParticles ()[1]; }  
                inline const particlePtr& recoil() const { return outParticles()[1]; }  
    
                virtual bool initKinematicsData(const TClonesArray& prodKinPartNames);  
                virtual bool readKinematicsData(const TClonesArray& prodKinMomenta);    

                virtual bool revertMomenta();  

                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 "diffractiveDissVertex"; }  

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


        protected:

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


        private:

                int      _nmbProdKinPart;  
                TVector3 _beamMomCache;    
                TVector3 _recoilMomCache;  
                TVector3 _targetMomCache;  

                static bool _debug;  

        };


        inline
        diffractiveDissVertexPtr
        createDiffractiveDissVertex(const particlePtr& beam,
                                    const particlePtr& target,
                                    const particlePtr& XParticle,
                                    const particlePtr& recoil = particlePtr())
        {
                diffractiveDissVertexPtr vert(new diffractiveDissVertex(beam, target, XParticle, recoil));
                return vert;
        }


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


}  // namespace rpwa


#endif  // DIFFRACTIVEDISSVERTEX_H