LArHierarchyHelper.h

Go to the documentation of this file.

 
#ifndef LAR_HIERARCHY_HELPER_H
#define LAR_HIERARCHY_HELPER_H 1
 
#include "Pandora/PandoraInternal.h"
 
#include "Helpers/MCParticleHelper.h"
 
#include "larpandoracontent/LArHelpers/LArMCParticleHelper.h"
#include "larpandoracontent/LArHelpers/LArPfoHelper.h"
 
namespace lar_content
{
 
class LArHierarchyHelper
{
public:
    class FoldingParameters
    {
    public:
        FoldingParameters();
 
        FoldingParameters(const bool foldDynamic, const float cosAngleTolerance = 0.9962f);
 
        FoldingParameters(const int foldingTier);
 
        bool m_foldToLeadingShowers; 
        bool m_foldToTier;           
        bool m_foldDynamic;          
        float m_cosAngleTolerance;   
        int m_tier;                  
    };
 
    class QualityCuts
    {
    public:
        QualityCuts();
 
        QualityCuts(const float minPurity, const float minCompleteness);
 
        const float m_minPurity;       
        const float m_minCompleteness; 
    };
 
    class MCHierarchy
    {
    public:
        class ReconstructabilityCriteria
        {
        public:
            ReconstructabilityCriteria();
 
            ReconstructabilityCriteria(const ReconstructabilityCriteria &obj);
 
            ReconstructabilityCriteria(const unsigned int minHits, const unsigned int minHitsForGoodView, const unsigned int minGoodViews,
                const bool removeNeutrons);
 
            const unsigned int m_minHits;            
            const unsigned int m_minHitsForGoodView; 
            const unsigned int m_minGoodViews;       
            const bool m_removeNeutrons;             
        };
 
        class Node;
        typedef std::vector<const Node *> NodeVector;
        typedef std::list<const Node *> NodeList;
        typedef std::map<const pandora::MCParticle *, NodeVector> MCNodeVectorMap;
 
        class Node
        {
        public:
            Node(MCHierarchy &hierarchy, const pandora::MCParticle *pMCParticle, const int tier = 1);
 
            Node(MCHierarchy &hierarchy, const pandora::MCParticleList &mcParticleList, const pandora::CaloHitList &caloHitList, const int tier = 1);
 
            virtual ~Node();
 
            bool IsReconstructable() const;
 
            void FillHierarchy(const pandora::MCParticle *pRoot, const FoldingParameters &foldParameters);
 
            void FillFlat(const pandora::MCParticle *pRoot);
 
            const NodeVector &GetChildren() const;
 
            int GetId() const;
 
            const pandora::MCParticle *GetLeadingMCParticle() const;
 
            const pandora::MCParticleList &GetMCParticles() const;
 
            const pandora::CaloHitList &GetCaloHits() const;
 
            int GetParticleId() const;
 
            int GetHierarchyTier() const;
 
            bool IsNeutrinoInduced() const;
 
            bool IsTestBeamParticle() const;
 
            bool IsCosmicRay() const;
 
            bool IsLeadingLepton() const;
 
            const std::string ToString(const std::string &prefix) const;
 
        private:
            void SetLeadingLepton();
 
            MCHierarchy &m_hierarchy;                  
            pandora::MCParticleList m_mcParticles;     
            pandora::CaloHitList m_caloHits;           
            NodeVector m_children;                     
            const pandora::MCParticle *m_mainParticle; 
            int m_tier;                                
            int m_pdg;                                 
            bool m_isLeadingLepton;                    
 
            friend class MCHierarchy;
        };
 
        MCHierarchy();
 
        MCHierarchy(const ReconstructabilityCriteria &recoCriteria);
 
        virtual ~MCHierarchy();
 
        void FillHierarchy(const pandora::MCParticleList &mcParticleList, const pandora::CaloHitList &caloHitList, const FoldingParameters &foldParameters);
 
        void InterpretHierarchy(const pandora::MCParticle *const pRoot, pandora::MCParticleList &leadingParticles,
            pandora::MCParticleList &childParticles, const float cosAngleTolerance) const;
 
        const pandora::MCParticle *GetNeutrino() const;
 
        const NodeVector &GetInteractions(const pandora::MCParticle *pRoot) const;
 
        void GetRootMCParticles(pandora::MCParticleList &rootMCParticles) const;
 
        void GetFlattenedNodes(const pandora::MCParticle *const pRoot, NodeVector &nodeVector) const;
 
        void RegisterNode(const Node *pNode);
 
        const std::string ToString() const;
 
    private:
        void CollectContinuations(const pandora::MCParticle *pRoot, pandora::MCParticleList &continuingParticles,
            pandora::MCParticleList &childParticles, const float cosAngleTolerance) const;
 
        bool IsReconstructable(const pandora::MCParticle *pMCParticle) const;
 
        bool IsReconstructable(const pandora::CaloHitList &caloHits) const;
 
        MCNodeVectorMap m_interactions;            
        ReconstructabilityCriteria m_recoCriteria; 
        std::map<const pandora::MCParticle *, pandora::CaloHitList> m_mcToHitsMap; 
        std::map<const Node *, int> m_nodeToIdMap;                                 
        int m_nextNodeId;                                                          
    };
 
    class RecoHierarchy
    {
    public:
        class Node;
        typedef std::vector<const Node *> NodeVector;
        typedef std::list<const Node *> NodeList;
        typedef std::map<const pandora::ParticleFlowObject *, NodeVector> RecoNodeVectorMap;
 
        class Node
        {
        public:
            Node(const RecoHierarchy &hierarchy, const pandora::ParticleFlowObject *pPfo);
 
            Node(const RecoHierarchy &hierarchy, const pandora::PfoList &pfoList, const pandora::CaloHitList &caloHitList);
 
            virtual ~Node();
 
            void FillHierarchy(const pandora::ParticleFlowObject *pRoot, const FoldingParameters &foldParameters);
 
            void FillFlat(const pandora::ParticleFlowObject *pRoot);
 
            const NodeVector &GetChildren() const;
 
            const pandora::PfoList &GetRecoParticles() const;
 
            const pandora::ParticleFlowObject *GetLeadingPfo() const;
 
            const pandora::CaloHitList &GetCaloHits() const;
 
            int GetParticleId() const;
 
            const std::string ToString(const std::string &prefix) const;
 
        private:
            const RecoHierarchy &m_hierarchy;             
            pandora::PfoList m_pfos;                      
            pandora::CaloHitList m_caloHits;              
            NodeVector m_children;                        
            const pandora::ParticleFlowObject *m_mainPfo; 
            int m_pdg;                                    
        };
 
        RecoHierarchy();
 
        virtual ~RecoHierarchy();
 
        void FillHierarchy(const pandora::PfoList &pfoList, const FoldingParameters &foldParameters);
 
        const NodeVector &GetInteractions(const pandora::ParticleFlowObject *pRoot) const;
 
        void GetRootPfos(pandora::PfoList &rootPfos) const;
 
        void GetFlattenedNodes(const pandora::ParticleFlowObject *const pRoot, NodeVector &nodeVector) const;
 
        const pandora::ParticleFlowObject *GetNeutrino() const;
 
        const std::string ToString() const;
 
    private:
        RecoNodeVectorMap m_interactions; 
    };
 
    class MCMatches
    {
    public:
        MCMatches(const MCHierarchy::Node *pMCParticle);
 
        void AddRecoMatch(const RecoHierarchy::Node *pReco, const int nSharedHits);
 
        const MCHierarchy::Node *GetMC() const;
 
        const RecoHierarchy::NodeVector &GetRecoMatches() const;
 
        unsigned int GetSharedHits(const RecoHierarchy::Node *pReco) const;
 
        float GetPurity(const RecoHierarchy::Node *pReco, const bool adcWeighted = false) const;
 
        float GetPurity(const RecoHierarchy::Node *pReco, const pandora::HitType view, const bool adcWeighted = false) const;
 
        float GetCompleteness(const RecoHierarchy::Node *pReco, const bool adcWeighted = false) const;
 
        float GetCompleteness(const RecoHierarchy::Node *pReco, const pandora::HitType view, const bool adcWeighted = false) const;
 
        size_t GetNRecoMatches() const;
 
        bool IsQuality(const QualityCuts &qualityCuts) const;
 
    private:
        float GetPurity(const pandora::CaloHitVector &intersection, const pandora::CaloHitList &recoHits, const bool adcWeighted) const;
 
        float GetCompleteness(const pandora::CaloHitVector &intersection, const pandora::CaloHitList &mcHits, const bool adcWeighted) const;
 
        const MCHierarchy::Node *m_pMCParticle; 
        RecoHierarchy::NodeVector m_recoNodes;  
        pandora::IntVector m_sharedHits;        
    };
 
    typedef std::vector<MCMatches> MCMatchesVector;
    typedef std::map<const pandora::MCParticle *, MCMatchesVector> InteractionInfo;
 
    class MatchInfo
    {
    public:
        MatchInfo(const MCHierarchy &mcHierarchy, const RecoHierarchy &recoHierarchy);
 
        MatchInfo(const MCHierarchy &mcHierarchy, const RecoHierarchy &recoHierarchy, const QualityCuts &qualityCuts);
 
        void Match();
 
        const MCMatchesVector &GetMatches(const pandora::MCParticle *const pRoot) const;
 
        const RecoHierarchy::NodeVector &GetUnmatchedReco() const;
 
        unsigned int GetNMCNodes(const pandora::MCParticle *const pRoot) const;
 
        unsigned int GetNNeutrinoMCNodes(const pandora::MCParticle *const pRoot) const;
 
        unsigned int GetNCosmicRayMCNodes(const pandora::MCParticle *const pRoot) const;
 
        unsigned int GetNTestBeamMCNodes(const pandora::MCParticle *const pRoot) const;
 
        const MCHierarchy &GetMCHierarchy() const;
 
        const RecoHierarchy &GetRecoHierarchy() const;
 
        void GetRootMCParticles(pandora::MCParticleList &rootMCParticles) const;
 
        const QualityCuts &GetQualityCuts() const;
 
        void Print(const MCHierarchy &mcHierarchy) const;
 
    private:
        const MCHierarchy &m_mcHierarchy;          
        const RecoHierarchy &m_recoHierarchy;      
        InteractionInfo m_matches;                 
        RecoHierarchy::NodeVector m_unmatchedReco; 
        QualityCuts m_qualityCuts;                 
    };
 
    static void FillMCHierarchy(const pandora::MCParticleList &mcParticleList, const pandora::CaloHitList &caloHitList,
        const FoldingParameters &foldParameters, MCHierarchy &hierarchy);
 
    static void FillRecoHierarchy(const pandora::PfoList &pfoList, const FoldingParameters &foldParameters, RecoHierarchy &hierarchy);
 
    static void MatchHierarchies(MatchInfo &matchInfo);
 
private:
    typedef std::set<const pandora::MCParticle *> MCParticleSet;
    typedef std::set<const pandora::ParticleFlowObject *> PfoSet;
 
    static void GetMCPrimaries(const pandora::MCParticle *pRoot, MCParticleSet &primaries);
 
    static void GetRecoPrimaries(const pandora::ParticleFlowObject *pRoot, PfoSet &primaries);
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArHierarchyHelper::MCHierarchy::NodeVector &LArHierarchyHelper::MCHierarchy::Node::GetChildren() const
{
    return m_children;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::MCParticleList &LArHierarchyHelper::MCHierarchy::Node::GetMCParticles() const
{
    return m_mcParticles;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::CaloHitList &LArHierarchyHelper::MCHierarchy::Node::GetCaloHits() const
{
    return m_caloHits;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::MCParticle *LArHierarchyHelper::MCHierarchy::Node::GetLeadingMCParticle() const
{
    return m_mainParticle;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int LArHierarchyHelper::MCHierarchy::Node::GetParticleId() const
{
    return m_pdg;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int LArHierarchyHelper::MCHierarchy::Node::GetHierarchyTier() const
{
    return m_tier;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool LArHierarchyHelper::MCHierarchy::Node::IsNeutrinoInduced() const
{
    return !(LArHierarchyHelper::MCHierarchy::Node::IsTestBeamParticle() || LArHierarchyHelper::MCHierarchy::Node::IsCosmicRay());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool LArHierarchyHelper::MCHierarchy::Node::IsLeadingLepton() const
{
    return m_isLeadingLepton;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void LArHierarchyHelper::MCHierarchy::Node::SetLeadingLepton()
{
    m_isLeadingLepton = true;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArHierarchyHelper::RecoHierarchy::NodeVector &LArHierarchyHelper::RecoHierarchy::Node::GetChildren() const
{
    return m_children;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::ParticleFlowObject *LArHierarchyHelper::RecoHierarchy::Node::GetLeadingPfo() const
{
    return m_mainPfo;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArHierarchyHelper::MCHierarchy::Node *LArHierarchyHelper::MCMatches::GetMC() const
{
    return m_pMCParticle;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArHierarchyHelper::RecoHierarchy::NodeVector &LArHierarchyHelper::MCMatches::GetRecoMatches() const
{
    return m_recoNodes;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline size_t LArHierarchyHelper::MCMatches::GetNRecoMatches() const
{
    return m_recoNodes.size();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArHierarchyHelper::MCMatchesVector &LArHierarchyHelper::MatchInfo::GetMatches(const pandora::MCParticle *const pRoot) const
{
    if (m_matches.find(pRoot) == m_matches.end())
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_FOUND);
 
    return m_matches.at(pRoot);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArHierarchyHelper::RecoHierarchy::NodeVector &LArHierarchyHelper::MatchInfo::GetUnmatchedReco() const
{
    return m_unmatchedReco;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArHierarchyHelper::MCHierarchy &LArHierarchyHelper::MatchInfo::GetMCHierarchy() const
{
    return m_mcHierarchy;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArHierarchyHelper::RecoHierarchy &LArHierarchyHelper::MatchInfo::GetRecoHierarchy() const
{
    return m_recoHierarchy;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArHierarchyHelper::QualityCuts &LArHierarchyHelper::MatchInfo::GetQualityCuts() const
{
    return m_qualityCuts;
}
 
} // namespace lar_content
 
#endif // #ifndef LAR_HIERARCHY_HELPER_H