RecoHierarchy class. More...

#include <LArHierarchyHelper.h>

Classes
class	Node
	Node class. More...

Public Types
typedef std::vector< const Node * >	NodeVector

typedef std::list< const Node * >	NodeList

Public Member Functions
	RecoHierarchy ()
	Default constructor. More...

virtual	~RecoHierarchy ()
	Destructor. More...

void	FillHierarchy (const pandora::PfoList &pfoList, const FoldingParameters &foldParameters)
	Creates a reconstructed hierarchy representation. Without folding this will be a mirror image of the standard ParticleFlowObject (PFO) relationships. However, with folding options selected the hierarchy structure will group together PFOs into nodes based on the folding requirements. More...

const NodeVector &	GetRootNodes () const
	Retrieve the root nodes in this hierarchy. More...

void	GetFlattenedNodes (NodeVector &nodeVector) const
	Retrieve a flat vector of the nodes in the hierarchy. More...

const pandora::ParticleFlowObject *	GetNeutrino () const
	Retrieve the neutrino at the root of the hierarchy if it exists. More...

const std::string	ToString () const
	Produce a string representation of the hierarchy. More...

Private Attributes
NodeVector	m_rootNodes
	The leading nodes (e.g. primary particles, cosmic rays, ...) More...

const pandora::ParticleFlowObject *	m_pNeutrino
	The incident neutrino, if it exists. More...

Detailed Description

RecoHierarchy class.

Definition at line 426 of file LArHierarchyHelper.h.

Member Typedef Documentation

typedef std::list<const Node *> lar_content::LArHierarchyHelper::RecoHierarchy::NodeList

Definition at line 431 of file LArHierarchyHelper.h.

typedef std::vector<const Node *> lar_content::LArHierarchyHelper::RecoHierarchy::NodeVector

Definition at line 429 of file LArHierarchyHelper.h.

Constructor & Destructor Documentation

lar_content::LArHierarchyHelper::RecoHierarchy::RecoHierarchy ( )

Default constructor.

Definition at line 764 of file LArHierarchyHelper.cc.

                                                : m_pNeutrino{nullptr}
 {
 }

lar_content::LArHierarchyHelper::RecoHierarchy::~RecoHierarchy ( )

virtual

Destructor.

Definition at line 770 of file LArHierarchyHelper.cc.

 {
     for (const Node *pNode : m_rootNodes)
         delete pNode;
     m_rootNodes.clear();
 }

Member Function Documentation

void lar_content::LArHierarchyHelper::RecoHierarchy::FillHierarchy	(	const pandora::PfoList &	pfoList,
		const FoldingParameters &	foldParameters
	)

Creates a reconstructed hierarchy representation. Without folding this will be a mirror image of the standard ParticleFlowObject (PFO) relationships. However, with folding options selected the hierarchy structure will group together PFOs into nodes based on the folding requirements.

    If only folding back to primaries, the hierarchy will be relatively flat, with a top-level neutrino or test beam
    particle, if appropriate, and then a set of leaf nodes, one for each primary particles also containing the PFOs (and
    corresponding hits) from daughter particles.

    If only folding back to leading shower particles, the hierarchy will largely mirror the standard PFO hierarchy, but,
    when a shower particle is reached (based on the track/shower characterisation), this particle and all daughter particles
    will be represented by a single leaf node.

    If folding back to both primary and leading shower particles the hierarchy will again be rather flat, but in this case,
    if a primary track-like particle has a downstream shower particle then all downstream particles above the shower-like
    particle will be folded into the primary node, but a new, daughter leaf node will be created for the shower-like
    particle and all of its daughters, and a parent-child relationship will be formed between the primary node and shower
    node.

Parameters

pfoList	The list of PFOs with which to fill the hierarchy
foldParameters	The folding parameters to use for the hierarchy

Definition at line 779 of file LArHierarchyHelper.cc.

 {
     PfoSet primarySet;
     m_pNeutrino = LArHierarchyHelper::GetRecoPrimaries(pfoList, primarySet);
     PfoList primaries(primarySet.begin(), primarySet.end());
     primaries.sort(LArPfoHelper::SortByNHits);
     if (foldParameters.m_foldToTier && foldParameters.m_tier == 1)
     {
         for (const ParticleFlowObject *pPrimary : primaries)
         {
             PfoList allParticles;
             // ATTN - pPrimary gets added to the list of downstream PFOs, not just the child PFOs
             LArPfoHelper::GetAllDownstreamPfos(pPrimary, allParticles);
             CaloHitList allHits;
             for (const ParticleFlowObject *pPfo : allParticles)
                 LArPfoHelper::GetAllCaloHits(pPfo, allHits);
             m_rootNodes.emplace_back(new Node(*this, allParticles, allHits));
         }
     }
     else if (foldParameters.m_foldToLeadingShowers)
     {
         for (const ParticleFlowObject *pPrimary : primaries)
         {
             PfoList allParticles;
             int pdg{std::abs(pPrimary->GetParticleId())};
             const bool isShower{pdg == E_MINUS};
             // ATTN - pPrimary gets added to the list of downstream PFOs, not just the child PFOs
             if (isShower)
                 LArPfoHelper::GetAllDownstreamPfos(pPrimary, allParticles);
             else
                 allParticles.emplace_back(pPrimary);
 
             CaloHitList allHits;
             for (const ParticleFlowObject *pPfo : allParticles)
                 LArPfoHelper::GetAllCaloHits(pPfo, allHits);
             Node *pNode{new Node(*this, allParticles, allHits)};
             m_rootNodes.emplace_back(pNode);
             if (!isShower)
             {
                 // Find the children of this particle and recursively add them to the hierarchy
                 const PfoList &children{pPrimary->GetDaughterPfoList()};
                 for (const ParticleFlowObject *pChild : children)
                     pNode->FillHierarchy(pChild, foldParameters);
             }
         }
     }
     else
     {
         // Dynamic fold, Unfolded and fold to tier > 1 have the same behaviour for primaries
         for (const ParticleFlowObject *pPrimary : primaries)
         {
             PfoList allParticles{pPrimary};
             CaloHitList allHits;
             for (const ParticleFlowObject *pPfo : allParticles)
                 LArPfoHelper::GetAllCaloHits(pPfo, allHits);
             Node *pNode{new Node(*this, allParticles, allHits)};
             m_rootNodes.emplace_back(pNode);
             // Find the children of this particle and recursively add them to the hierarchy
             const PfoList &children{pPrimary->GetDaughterPfoList()};
             for (const ParticleFlowObject *pChild : children)
                 pNode->FillHierarchy(pChild, foldParameters.m_foldToLeadingShowers);
         }
     }
 }

void lar_content::LArHierarchyHelper::RecoHierarchy::GetFlattenedNodes ( NodeVector & nodeVector ) const

Retrieve a flat vector of the nodes in the hierarchy.

Parameters

nodeVector The output vector for the nodes in the hierarchy in breadth first order

Definition at line 846 of file LArHierarchyHelper.cc.

 {
     NodeList queue;
     for (const Node *pNode : m_rootNodes)
     {
         nodeVector.emplace_back(pNode);
         queue.emplace_back(pNode);
     }
     while (!queue.empty())
     {
         const NodeVector &children{queue.front()->GetChildren()};
         queue.pop_front();
         for (const Node *pChild : children)
         {
             nodeVector.emplace_back(pChild);
             queue.emplace_back(pChild);
         }
     }
 }

const pandora::ParticleFlowObject * lar_content::LArHierarchyHelper::RecoHierarchy::GetNeutrino ( ) const

inline

Retrieve the neutrino at the root of the hierarchy if it exists.

Returns: The address of the incident neutrino (nullptr if it doesn't exist)

Definition at line 992 of file LArHierarchyHelper.h.

 {
     return m_pNeutrino;
 }

const LArHierarchyHelper::RecoHierarchy::NodeVector & lar_content::LArHierarchyHelper::RecoHierarchy::GetRootNodes ( ) const

inline

Retrieve the root nodes in this hierarchy.

Returns: The root nodes in this hierarchy

Definition at line 985 of file LArHierarchyHelper.h.

 {
     return m_rootNodes;
 }

const std::string lar_content::LArHierarchyHelper::RecoHierarchy::ToString ( ) const

Produce a string representation of the hierarchy.

Returns: The string representation of the hierarchy

Definition at line 868 of file LArHierarchyHelper.cc.

 {
     std::string str;
     for (const Node *pNode : m_rootNodes)
         str += pNode->ToString("") + "\n";
 
     return str;
 }

Member Data Documentation

const pandora::ParticleFlowObject* lar_content::LArHierarchyHelper::RecoHierarchy::m_pNeutrino

private

The incident neutrino, if it exists.

Definition at line 584 of file LArHierarchyHelper.h.

NodeVector lar_content::LArHierarchyHelper::RecoHierarchy::m_rootNodes

private

The leading nodes (e.g. primary particles, cosmic rays, ...)

Definition at line 583 of file LArHierarchyHelper.h.

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation