fsVertex.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 final state vertex decay topology
//      class is just used for internal book keeping
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef FSVERTEX_H
#define FSVERTEX_H


#include <boost/shared_ptr.hpp>

#include "interactionVertex.h"


namespace rpwa {


        class fsVertex;
        typedef boost::shared_ptr<fsVertex> fsVertexPtr;


        class fsVertex : public interactionVertex {

        public:
  
                fsVertex(const particlePtr& fsParticle);  
                fsVertex(const fsVertex& vert);
                virtual ~fsVertex();
                
                fsVertexPtr clone(const bool cloneInParticles  = false,
                                  const bool                   = false) const  
                { return fsVertexPtr(doClone(cloneInParticles, false)); }

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

                // final-state specific accessors
                inline particlePtr&       fsParticle()       { return inParticles()[0]; }  
                inline const particlePtr& fsParticle() const { return inParticles()[0]; }  

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

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


        protected:

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


        private:

                static bool _debug;  

        };


        inline
        fsVertexPtr
        createFsVertex(const particlePtr& fsParticle)
        {
                fsVertexPtr vert(new fsVertex(fsParticle));
                return vert;
        }


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


}  // namespace rpwa


#endif  // FSVERTEX_H