isobarDecayTopology.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:
//      container class that holds all external information for
//      amplitude calculation of isobar decay
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef ISOBARDECAYTOPOLOGY_H
#define ISOBARDECAYTOPOLOGY_H

#include <boost/tuple/tuple.hpp>

#include "isobarDecayVertex.h"
#include "decayTopology.h"


namespace rpwa {  

        // amplitude symmetrization info
        struct symTermMap {
                symTermMap(const std::complex<double>&      f,
                           const std::vector<unsigned int>& m)
                        : factor       (f),
                          fsPartPermMap(m)
                { }
                std::complex<double>      factor;         
                std::vector<unsigned int> fsPartPermMap;  
        };
        

        class isobarDecayTopology;
        typedef boost::shared_ptr<isobarDecayTopology> isobarDecayTopologyPtr;
        

        class isobarDecayTopology : public decayTopology {

        public:

                isobarDecayTopology();
                isobarDecayTopology(const productionVertexPtr&               productionVertex,
                                    const std::vector<isobarDecayVertexPtr>& isobarDecayVertices,
                                    const std::vector<particlePtr>&          fsParticles,
                                    const bool                               performTopologyCheck = true);
                isobarDecayTopology(const productionVertexPtr&               productionVertex,
                                    const std::vector<interactionVertexPtr>& isobarDecayVertices,
                                    const std::vector<particlePtr>&          fsParticles,
                                    const bool                               performTopologyCheck = true);
                isobarDecayTopology(const isobarDecayTopology&               topo);
                isobarDecayTopology(const decayTopology&                     topo);
                virtual ~isobarDecayTopology();

                isobarDecayTopology& operator =(const isobarDecayTopology& topo);
                isobarDecayTopology& operator =(const decayTopology&       topo);
                isobarDecayTopologyPtr clone(const bool cloneFsParticles    = false,
                                             const bool cloneProdKinematics = false) const  
                { return isobarDecayTopologyPtr(doClone(cloneFsParticles, cloneProdKinematics)); }
                virtual void clear();  

                const std::vector<isobarDecayVertexPtr>& isobarDecayVertices() const { return _isobarVertices;    }  
                const isobarDecayVertexPtr&              XIsobarDecayVertex () const { return _isobarVertices[0]; }  

                bool checkTopology   () const;  
                bool checkConsistency() const;  

                isobarDecayTopology subDecay(const nodeDesc& startNd,
                                             const bool      linkToParentTopo = false);  
                isobarDecayTopology subDecay(const isobarDecayVertexPtr& startVert,
                                             const bool                  linkToParentTopo = false)
                { return subDecay(node(startVert), linkToParentTopo); }  

                void addDecay(const isobarDecayTopology& topo);  

                static isobarDecayTopology joinDaughterDecays
                (const isobarDecayVertexPtr&             parentVertex,
                 const std::vector<isobarDecayTopology>& daughterDecays);  
                static isobarDecayTopology joinDaughterDecays
                (const isobarDecayVertexPtr& parentVertex,
                 const isobarDecayTopology&  daughter1Decay,
                 const isobarDecayTopology&  daughter2Decay);  

                const TLorentzVector& calcIsobarLzVec();  

                void calcIsobarCharges   (bool quiet = false);  
                void calcIsobarBaryonNmbs();                    

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

                virtual std::ostream& writeGraphViz(std::ostream&      out);          
                virtual bool          writeGraphViz(const std::string& outFileName);  

                static bool debug() { return _debug; }                             
                static void setDebug(const bool debug = true) { _debug = debug; }  
         
                double getIsospinClebschGordanProduct(isobarDecayVertexPtr vertex = isobarDecayVertexPtr()) const;  

                std::vector<symTermMap> getIsospinSymmetrization();  
                std::vector<symTermMap> getBoseSymmetrization() const;     

                bool isobarIsAffectedByPermutation(const isobarDecayVertexPtr& vertex, const std::vector<unsigned int>& permutation) const; 
                bool daughtersAreAffectedByPermutation(const isobarDecayVertexPtr& vertex, const std::vector<unsigned int>& permutation) const; 
                std::vector<unsigned int> getFsPartIndicesConnectedToVertex(const isobarDecayVertexPtr& vertex) const; 

                std::vector<unsigned int> findIsobarBoseSymVertices() const;  


        protected:

                isobarDecayTopology& constructDecay(const productionVertexPtr&               productionVertex,
                                                    const std::vector<isobarDecayVertexPtr>& isobarDecayVertices,
                                                    const std::vector<particlePtr>&          fsParticles,
                                                    const bool                               performTopologyCheck = true);  
                isobarDecayTopology& constructDecay(const productionVertexPtr&               productionVertex,
                                                    const std::vector<interactionVertexPtr>& isobarDecayVertices,
                                                    const std::vector<particlePtr>&          fsParticles,
                                                    const bool                               performTopologyCheck = true);  


        private:

                virtual isobarDecayTopology* doClone(const bool cloneFsParticles,
                                                     const bool cloneProdKinematics) const;  

                void buildIsobarVertexArray();  

                virtual void genBoseSymTermMaps
                (const std::map<std::string, std::vector<unsigned int> >&     origFsPartIndices,
                 const std::map<std::string, std::vector<unsigned int> >&     newFsPartIndices,
                 std::map<std::string, std::vector<unsigned int> >::iterator& newFsPartIndicesEntry,
                 std::vector<symTermMap>&                                     symTermMaps) const;  

                std::vector<isobarDecayVertexPtr> _isobarVertices;  

                static bool _debug;  

        };


        inline
        isobarDecayTopologyPtr
        createIsobarDecayTopology(const productionVertexPtr&               productionVertex,
                                  const std::vector<isobarDecayVertexPtr>& isobarDecayVertices,
                                  const std::vector<particlePtr>&          fsParticles,
                                  const bool                               performTopologyCheck = true)
        {
                isobarDecayTopologyPtr topo(new isobarDecayTopology(productionVertex, isobarDecayVertices,
                                                                    fsParticles, performTopologyCheck));
                return topo;
        }


        inline
        isobarDecayTopologyPtr
        createIsobarDecayTopology(const productionVertexPtr&               productionVertex,
                                  const std::vector<interactionVertexPtr>& isobarDecayVertices,
                                  const std::vector<particlePtr>&          fsParticles,
                                  const bool                               performTopologyCheck = true)
        {
                isobarDecayTopologyPtr topo(new isobarDecayTopology(productionVertex, isobarDecayVertices,
                                                                    fsParticles, performTopologyCheck));
                return topo;
        }
        
        
        inline
        isobarDecayTopologyPtr
        createIsobarDecayTopology(const isobarDecayTopology& topo)
        {
                isobarDecayTopologyPtr topoCopy(new isobarDecayTopology(topo));
                return topoCopy;
        }
        
        
        inline
        isobarDecayTopologyPtr
        createIsobarDecayTopology(const decayTopology& topo)
        {
                isobarDecayTopologyPtr topoCopy(new isobarDecayTopology(topo));
                return topoCopy;
        }


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


} // namespace rpwa


#endif  // ISOBARDECAYTOPOLOGY_H