interactionVertex.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:
//      base class that desbribes general interaction vertex between particles
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef INTERACTIONVERTEX_H
#define INTERACTIONVERTEX_H


#include <iostream>
#include <vector>
#include <complex>

#include "TLorentzRotation.h"

#include "particle.h"


class TClonesArray;


namespace rpwa {

  
        class interactionVertex;
        typedef boost::shared_ptr<interactionVertex> interactionVertexPtr;


        class interactionVertex {

        public:
  
                interactionVertex();
                interactionVertex(const interactionVertex& vert);
                virtual ~interactionVertex();
                
                interactionVertex& operator =(const interactionVertex& vert);
                interactionVertexPtr clone(const bool cloneInParticles  = false,
                                           const bool cloneOutParticles = false) const  
                { return interactionVertexPtr(doClone(cloneInParticles, cloneOutParticles)); }
                virtual void clear();

                // comparison operators that check equality of all member variables
                bool operator ==(const interactionVertex& rhsVert) { return this->isEqualTo(rhsVert); }
                bool operator !=(const interactionVertex& rhsVert) { return not (*this == rhsVert);   }

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

                void transformOutParticles(const TLorentzRotation& L);  

                inline unsigned int nmbInParticles () const { return _inParticles.size();  }  
                inline unsigned int nmbOutParticles() const { return _outParticles.size(); }  

                inline std::vector<particlePtr>&       inParticles ()       { return _inParticles;  }  
                inline std::vector<particlePtr>&       outParticles()       { return _outParticles; }  
                inline const std::vector<particlePtr>& inParticles () const { return _inParticles;  }  
                inline const std::vector<particlePtr>& outParticles() const { return _outParticles; }  

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

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


        protected:

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

                virtual bool isEqualTo(const interactionVertex& vert) const;  

                void cloneInParticles ();  
                void cloneOutParticles();  

                std::vector<particlePtr> _inParticles;   
                std::vector<particlePtr> _outParticles;  


        private:

                static bool _debug;  
        
        };


        inline
        interactionVertexPtr
        createInteractionVertex()
        {
                interactionVertexPtr vert(new interactionVertex());
                return vert;
        }


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


}  // namespace rpwa


#endif  // INTERACTIONVERTEX_H