decayTopology.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
//      internally the decay process is represented as a graph
//      the graph is constraint to contain exactly one production
//      vertex and at least one interaction vertex; in addtion for
//      each final-state particle a corresponding final-state vertex
//      is created for internal use
//
//      "final-state" particles are the measured decay daughters;
//      additional final-state particles that belong to the production
//      process are handled by the production vertex
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef DECAYTOPOLOGY_H
#define DECAYTOPOLOGY_H


#include <vector>
#include <map>

#include "TLorentzRotation.h"

#include "particle.h"
#include "productionVertex.h"
#include "interactionVertex.h"
#include "fsVertex.h"
#include "decayGraph.hpp"


class TClonesArray;
class TVector3;


namespace rpwa {


        class decayTopology;
        typedef boost::shared_ptr<decayTopology> decayTopologyPtr;
        typedef decayGraph<interactionVertex, particle> decayTopologyGraphType;


        class decayTopology : public decayTopologyGraphType {
        
        public:
                        
                decayTopology();
                decayTopology(const productionVertexPtr&               productionVertex,
                              const std::vector<interactionVertexPtr>& decayVertices,
                              const std::vector<particlePtr>&          fsParticles,
                              const bool                               performTopologyCheck = true);
                decayTopology(const decayTopology&                     topo);
                decayTopology(const decayTopologyGraphType&            graph);
                virtual ~decayTopology();

                decayTopology& operator =(const decayTopology&          topo);
                decayTopology& operator =(const decayTopologyGraphType& graph);
                decayTopologyPtr clone(const bool cloneFsParticles    = false,
                                       const bool cloneProdKinematics = false) const  
                { return decayTopologyPtr(doClone(cloneFsParticles, cloneProdKinematics)); }

                virtual void clear();  
    
                unsigned int nmbDecayVertices() const { return _decayVertices.size(); }  
                unsigned int nmbFsParticles  () const { return _fsParticles.size();   }  
                std::map<std::string, unsigned int> nmbIndistFsParticles() const;  

                int fsParticlesIntrinsicParity() const;  
                int spaceInvEigenValue()         const;  
                int reflectionEigenValue()       const;  

                const std::vector<particlePtr>&          fsParticles  () const { return _fsParticles;   }  
                const std::vector<interactionVertexPtr>& decayVertices() const { return _decayVertices; }  

                const particlePtr&          XParticle       () const { return productionVertex()->XParticle(); }  
                const productionVertexPtr&  productionVertex() const { return _prodVertex;                     }  
                const interactionVertexPtr& XDecayVertex    () const { return _decayVertices[0];               }  

                void transformFsParticles(const TLorentzRotation& L);  

                bool isVertex          (const interactionVertexPtr& vert) const;  
                bool isParticle        (const particlePtr&          part) const;  
                bool isProductionVertex(const interactionVertexPtr& vert) const;  
                bool isDecayVertex     (const interactionVertexPtr& vert) const;  
                int  decayVertexIndex  (const interactionVertexPtr& vert) const;  
                bool isFsVertex        (const interactionVertexPtr& vert) const;  
                bool isFsParticle      (const particlePtr&          part) const;  
                int  fsParticlesIndex  (const particlePtr&          part) const;  

                bool checkTopology   () const;                  
                bool checkConsistency() const { return true; }  

                decayTopology subDecay(const nodeDesc& startNd,
                                       const bool      linkToMotherTopo = false);  
                decayTopology subDecay(const interactionVertexPtr& startVert,
                                       const bool                  linkToParentTopo = false)
                { return subDecay(node(startVert), linkToParentTopo); }  

                void addDecay(const decayTopology& topo);  

                void setProductionVertex(const productionVertexPtr& productionVertex);  

                bool initKinematicsData(const TClonesArray& prodKinParticles,
                                        const TClonesArray& decayKinParticles);  

                bool readKinematicsData(const TClonesArray& prodKinMomenta,
                                        const TClonesArray& decayKinMomenta);    

                void fillKinematicsDataCache();  

                bool revertMomenta();  
                bool revertMomenta(const std::vector<unsigned int>& fsPartPermMap);  


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

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


        protected:

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

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

                void buildInternalData();  

                virtual interactionVertexPtr cloneNode(const nodeDesc& nd,
                                                       const bool      cloneInParticles  = false,
                                                       const bool      cloneOutParticles = false);
                virtual particlePtr          cloneEdge(const edgeDesc& ed);

        private:

                productionVertexPtr               _prodVertex;     
                std::vector<interactionVertexPtr> _decayVertices;  
                std::vector<particlePtr>          _fsParticles;    

                std::map<unsigned int, unsigned int> _fsDataPartIndexMap;  
                std::vector<TVector3>                _fsDataPartMomCache;  
    
                static bool _debug;  
    
        };
  

        inline
        decayTopologyPtr
        createDecayTopology(const productionVertexPtr&               productionVertex,
                            const std::vector<interactionVertexPtr>& decayVertices,
                            const std::vector<particlePtr>&          fsParticles,
                            const bool                               performTopologyCheck = true)
        {
                decayTopologyPtr topo(new decayTopology(productionVertex, decayVertices,
                                                        fsParticles, performTopologyCheck));
                return topo;
        }


        inline
        decayTopologyPtr
        createDecayTopology(const decayTopology& topo)
        {
                decayTopologyPtr topoCopy(new decayTopology(topo));
                return topoCopy;
        }


        inline
        decayTopologyPtr
        createDecayTopology(const decayTopologyGraphType& graph)
        {
                decayTopologyPtr topoCopy(new decayTopology(graph));
                return topoCopy;
        }


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


}  // namespace rpwa


#endif  // DECAYTOPOLOGY_H