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 bool selectRecoHits = false);

        const float m_minPurity;       
        const float m_minCompleteness; 
        const bool m_selectRecoHits;   
    };

    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, const int tier = 1);

            Node(const RecoHierarchy &hierarchy, const pandora::PfoList &pfoList, const pandora::CaloHitList &caloHitList, const int tier = 1);

            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;

            int GetHierarchyTier() 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_tier;                                   
            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; 
    };

    typedef std::map<const RecoHierarchy::Node *, const pandora::CaloHitList> SelectedRecoHitsMap;

    class MCMatches
    {
    public:
        MCMatches(const MCHierarchy::Node *pMCParticle);

        void AddRecoMatch(const RecoHierarchy::Node *pReco, const int nSharedHits, const pandora::CaloHitList &selectedRecoHits);

        const MCHierarchy::Node *GetMC() const;

        const RecoHierarchy::NodeVector &GetRecoMatches() const;

        const pandora::CaloHitList GetSelectedRecoHits(const RecoHierarchy::Node *pReco) 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;           
        SelectedRecoHitsMap m_selectedRecoHitsMap; 
    };

    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;

        const pandora::CaloHitList GetSelectedRecoHits(const RecoHierarchy::Node *pRecoNode, const pandora::CaloHitList &allMCHits) 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 int LArHierarchyHelper::RecoHierarchy::Node::GetHierarchyTier() const
{
    return m_tier;
}

//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------

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