lar_content::LArHierarchyHelper::MCHierarchy Class Reference

MCHierarchy class. More...

#include <LArHierarchyHelper.h>

Classes
class	Node
	Node class. More...
class	ReconstructabilityCriteria
	ReconstructabilityCriteria class. More...

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

Public Member Functions
	MCHierarchy ()
	Default constructor. More...
	MCHierarchy (const ReconstructabilityCriteria &recoCriteria)
	Construct a new MCHierarchy object using specified reconstructability criteria. More...
virtual	~MCHierarchy ()
	Destructor. More...
void	FillHierarchy (const pandora::MCParticleList &mcParticleList, const pandora::CaloHitList &caloHitList, const FoldingParameters &foldParameters)
	Creates an MC hierarchy representation. Without folding this will be a mirror image of the standard MCParticle relationships. However, with folding options selected the hierarchy structure will group together MC particles into nodes based on the folding requirements. More...
void	InterpretHierarchy (const pandora::MCParticle *const pRoot, pandora::MCParticleList &leadingParticles, pandora::MCParticleList &childParticles, const float cosAngleTolerance) const
	Interpret the hierarchy below a particular particle to determine if and how it should be folded. Folded particles are added to the leadingParticles list and child particles are added to the childParticles list. More...
const pandora::MCParticle *	GetNeutrino () const
	Retrieve the neutrino at the root of the hierarchy if it exists. More...
const NodeVector &	GetRootNodes () const
	Retrieve the root nodes in this hierarchy. More...
void	GetFlattenedNodes (NodeVector &nodeVector) const
	Retrieve a flat vector of the ndoes in the hierarchy. More...
void	RegisterNode (const Node *pNode)
	Register a node with the hierarchy. More...
const std::string	ToString () const
	Produce a string representation of the hierarchy. More...
bool	IsNeutrinoHierarchy () const
	Check if this is a neutrino hierarchy. More...
bool	IsTestBeamHierarchy () const
	Check if this is a test beam hierarchy. More...

Private Member Functions
void	CollectContinuations (const pandora::MCParticle *pRoot, pandora::MCParticleList &continuingParticles, pandora::MCParticleList &childParticles, const float cosAngleTolerance) const
	Identify downstream particles that represent continuations of the parent particle from a reconstruction perspective. More...
bool	IsReconstructable (const pandora::MCParticle *pMCParticle) const
	Checks if an individual particle meets reconstructability criteria. More...
bool	IsReconstructable (const pandora::CaloHitList &caloHits) const
	Checks if a set of hits meet reconstructability criteria. More...

Private Attributes
NodeVector	m_rootNodes
	The leading nodes (e.g. primary particles, cosmic rays, ...) More...
ReconstructabilityCriteria	m_recoCriteria
	The criteria used to determine if the node is reconstructable. More...
const pandora::MCParticle *	m_pNeutrino
	The incident neutrino, if it exists. More...
std::map< const pandora::MCParticle *, pandora::CaloHitList >	m_mcToHitsMap
	The map between MC particles and calo hits. More...
std::map< const Node *, int >	m_nodeToIdMap
	A map from nodes to unique ids. More...
int	m_nextNodeId
	The ID to use for the next node. More...

Detailed Description

MCHierarchy class.

Definition at line 88 of file LArHierarchyHelper.h.

Member Typedef Documentation

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

Definition at line 126 of file LArHierarchyHelper.h.

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

Definition at line 124 of file LArHierarchyHelper.h.

Constructor & Destructor Documentation

lar_content::LArHierarchyHelper::MCHierarchy::MCHierarchy

(

)

Default constructor.

Definition at line 75 of file LArHierarchyHelper.cc.

                                           : m_pNeutrino{nullptr}, m_nextNodeId{1}
{
}

lar_content::LArHierarchyHelper::MCHierarchy::MCHierarchy

(

const ReconstructabilityCriteria &

recoCriteria

)

Construct a new MCHierarchy object using specified reconstructability criteria.

Parameters

recoCriteria

The reconstructability criteria to be applied

Definition at line 81 of file LArHierarchyHelper.cc.

                                                                                         :
    m_recoCriteria(recoCriteria),
    m_pNeutrino{nullptr},
    m_nextNodeId{1}
{
}

lar_content::LArHierarchyHelper::MCHierarchy::~MCHierarchy ( )

virtual

Destructor.

Definition at line 90 of file LArHierarchyHelper.cc.

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

Member Function Documentation

void lar_content::LArHierarchyHelper::MCHierarchy::CollectContinuations ( const pandora::MCParticle *  pRoot, pandora::MCParticleList &  continuingParticles, pandora::MCParticleList &  childParticles, const float  cosAngleTolerance  ) const

private

Identify downstream particles that represent continuations of the parent particle from a reconstruction perspective.

Parameters

pRoot	The root MC particle
continuingParticles	An output list of the particles identified as continuations
childParticles	An output list of the particles identified as child particles given any continuations
cosAngleTolerance	The cosine of the maximum angle for which trajectories are considered continuous

Definition at line 339 of file LArHierarchyHelper.cc.

{
    const MCParticleList &children{pRoot->GetDaughterList()};
    MCParticleList foldCandidates;
    for (const MCParticle *pMCParticle : children)
    {
        const LArMCParticle *pLArMCParticle{dynamic_cast<const LArMCParticle *>(pMCParticle)};
        if (!pLArMCParticle)
            continue;
        // Only elastic and inelastic scattering can lead to folding
        if (LArMCParticleHelper::IsInelasticScatter(pMCParticle) || LArMCParticleHelper::IsElasticScatter(pMCParticle))
        {
            if (pMCParticle->GetParticleId() == pRoot->GetParticleId())
                foldCandidates.emplace_back(pMCParticle);
        }
        else if (!m_recoCriteria.m_removeNeutrons || (m_recoCriteria.m_removeNeutrons && pLArMCParticle->GetProcess() != MC_PROC_N_CAPTURE))
        {
            // Non-scattering process particles become leading candidates unless it's neutron capture and we're removing neutrons
            childParticles.emplace_back(pMCParticle);
        }
    }
    const MCParticle *pBestFoldCandidate{nullptr};
    float bestDp{std::numeric_limits<float>::max()};
    for (const MCParticle *pMCParticle : foldCandidates)
    {
        if (foldCandidates.size() == 1)
        {
            // No alternative options, so this is either the best folding option by default, or a sufficiently large scatter to
            // treat as a new particle for reconstruction purposes
            if (LArMCParticleHelper::AreTopologicallyContinuous(pRoot, pMCParticle, cosAngleTolerance))
                pBestFoldCandidate = pMCParticle;
        }
        else
        {
            // Assess which, if any, of the children might be a continuation of the trajectory, otherwise move to child candidates
            if (LArMCParticleHelper::AreTopologicallyContinuous(pRoot, pMCParticle, cosAngleTolerance))
            {
                const float dp{pRoot->GetMomentum().GetMagnitude() - pMCParticle->GetMomentum().GetMagnitude()};
                if (dp < bestDp)
                {
                    pBestFoldCandidate = pMCParticle;
                    bestDp = dp;
                }
            }
        }
    }
    if (pBestFoldCandidate)
    {
        continuingParticles.emplace_back(pBestFoldCandidate);
        const MCParticleList &newLeadingParticles{pBestFoldCandidate->GetDaughterList()};
        // We need to add the children as child particles to ensure these sub-hierarchies are explored...
        childParticles.insert(childParticles.begin(), newLeadingParticles.begin(), newLeadingParticles.end());
        // but this current best fold candidate may have been added to the child particles by previously, so remove it
        const auto iter{std::find(childParticles.begin(), childParticles.end(), pBestFoldCandidate)};
        if (iter != childParticles.end())
            childParticles.erase(iter);
        // Having found a particle to fold back at this level, continue to explore its downstream hierarchy for further folding
        // opportunities and make their respective children child particles for the folded node we are creating
        LArHierarchyHelper::MCHierarchy::CollectContinuations(pBestFoldCandidate, continuingParticles, childParticles, cosAngleTolerance);
    }
}

void lar_content::LArHierarchyHelper::MCHierarchy::FillHierarchy	(	const pandora::MCParticleList &	mcParticleList,
		const pandora::CaloHitList &	caloHitList,
		const FoldingParameters &	foldParameters
	)

Creates an MC hierarchy representation. Without folding this will be a mirror image of the standard MCParticle relationships. However, with folding options selected the hierarchy structure will group together MC particles 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 MC particles
    (and corresponding hits) from daughter particles.

    If only folding back to leading shower particles, the hierarchy will largely mirror the standard MCParticle hierarchy,
    but, when a shower particle is reached (for this purpose an electron or photon), 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 (i.e. not an electron or photon) 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

mcParticleList	The list of MC particles with which to fill the hierarchy
caloHitList	The list of hits with which to fill the hierarchy
foldParameters	The folding parameters to use for the hierarchy

Definition at line 99 of file LArHierarchyHelper.cc.

{
    const auto predicate = [](const MCParticle *pMCParticle) { return std::abs(pMCParticle->GetParticleId()) == NEUTRON; };
    m_mcToHitsMap.clear();
    for (const CaloHit *pCaloHit : caloHitList)
    {
        try
        {
            const MCParticle *pMCParticle{MCParticleHelper::GetMainMCParticle(pCaloHit)};
            m_mcToHitsMap[pMCParticle].emplace_back(pCaloHit);
        }
        catch (const StatusCodeException &)
        {
        }
    }

    MCParticleSet primarySet;
    m_pNeutrino = LArHierarchyHelper::GetMCPrimaries(mcParticleList, primarySet);
    MCParticleList primaries(primarySet.begin(), primarySet.end());
    primaries.sort(LArMCParticleHelper::SortByMomentum);
    if (m_recoCriteria.m_removeNeutrons)
        primaries.erase(std::remove_if(primaries.begin(), primaries.end(), predicate), primaries.end());
    if (foldParameters.m_foldToTier && foldParameters.m_tier == 1)
    {
        for (const MCParticle *pPrimary : primaries)
        {
            MCParticleList allParticles{pPrimary};
            if (!m_recoCriteria.m_removeNeutrons)
            {
                LArMCParticleHelper::GetAllDescendentMCParticles(pPrimary, allParticles);
            }
            else
            {
                // Collect track-like and shower-like particles together, but throw out neutrons and descendents
                MCParticleList dummy;
                LArMCParticleHelper::GetAllDescendentMCParticles(pPrimary, allParticles, allParticles, dummy);
            }
            CaloHitList allHits;
            for (const MCParticle *pMCParticle : allParticles)
            {
                // Not all MC particles will have hits
                if (m_mcToHitsMap.find(pMCParticle) != m_mcToHitsMap.end())
                {
                    const CaloHitList &caloHits(m_mcToHitsMap.at(pMCParticle));
                    allHits.insert(allHits.begin(), caloHits.begin(), caloHits.end());
                }
            }
            m_rootNodes.emplace_back(new Node(*this, allParticles, allHits));
        }
    }
    else if (foldParameters.m_foldToLeadingShowers)
    {
        for (const MCParticle *pPrimary : primaries)
        {
            MCParticleList allParticles{pPrimary};
            int pdg{std::abs(pPrimary->GetParticleId())};
            const bool isShower{pdg == E_MINUS || pdg == PHOTON};
            const bool isNeutron{pdg == NEUTRON};
            if (isShower || (isNeutron && !m_recoCriteria.m_removeNeutrons))
                LArMCParticleHelper::GetAllDescendentMCParticles(pPrimary, allParticles);
            CaloHitList allHits;
            for (const MCParticle *pMCParticle : allParticles)
            {
                // ATTN - Not all MC particles will have hits
                if (m_mcToHitsMap.find(pMCParticle) != m_mcToHitsMap.end())
                {
                    const CaloHitList &caloHits(m_mcToHitsMap.at(pMCParticle));
                    allHits.insert(allHits.begin(), caloHits.begin(), caloHits.end());
                }
            }
            Node *pNode{new Node(*this, allParticles, allHits)};
            m_rootNodes.emplace_back(pNode);
            if (!(isShower || isNeutron))
            {
                // Find the children of this particle and recursively add them to the hierarchy
                const MCParticleList &children{pPrimary->GetDaughterList()};
                for (const MCParticle *pChild : children)
                    pNode->FillHierarchy(pChild, foldParameters);
            }
        }
    }
    else if (foldParameters.m_foldDynamic)
    {
        for (const MCParticle *pPrimary : primaries)
        {
            MCParticleList leadingParticles, childParticles;
            this->InterpretHierarchy(pPrimary, leadingParticles, childParticles, foldParameters.m_cosAngleTolerance);
            CaloHitList allHits;
            for (const MCParticle *pMCParticle : leadingParticles)
            {
                // ATTN - Not all MC particles will have hits
                if (m_mcToHitsMap.find(pMCParticle) != m_mcToHitsMap.end())
                {
                    const CaloHitList &caloHits(m_mcToHitsMap.at(pMCParticle));
                    allHits.insert(allHits.begin(), caloHits.begin(), caloHits.end());
                }
            }

            Node *pNode{new Node(*this, leadingParticles, allHits)};
            m_rootNodes.emplace_back(pNode);
            for (const MCParticle *pChild : childParticles)
                pNode->FillHierarchy(pChild, foldParameters);
        }
    }
    else
    {
        // Unfolded and folded to tier > 1 have the same behaviour for primaries
        for (const MCParticle *pPrimary : primaries)
        {
            MCParticleList allParticles{pPrimary};
            CaloHitList allHits;
            for (const MCParticle *pMCParticle : allParticles)
            {
                // ATTN - Not all MC particles will have hits
                if (m_mcToHitsMap.find(pMCParticle) != m_mcToHitsMap.end())
                {
                    const CaloHitList &caloHits(m_mcToHitsMap.at(pMCParticle));
                    allHits.insert(allHits.begin(), caloHits.begin(), caloHits.end());
                }
            }
            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 MCParticleList &children{pPrimary->GetDaughterList()};
            for (const MCParticle *pChild : children)
                pNode->FillHierarchy(pChild, foldParameters);
        }
    }

    Node *pLeadingLepton{nullptr};
    float leadingLeptonEnergy{-std::numeric_limits<float>::max()};
    for (const Node *pNode : m_rootNodes)
    {
        const MCParticle *pMC{pNode->GetLeadingMCParticle()};
        if (pMC)
        {
            const int pdg{std::abs(pMC->GetParticleId())};
            if ((pdg == MU_MINUS || pdg == E_MINUS || pdg == TAU_MINUS) && pMC->GetEnergy() > leadingLeptonEnergy)
            {
                pLeadingLepton = const_cast<Node *>(pNode);
                leadingLeptonEnergy = pMC->GetEnergy();
            }
        }
    }
    if (pLeadingLepton)
        pLeadingLepton->SetLeadingLepton();
}

void lar_content::LArHierarchyHelper::MCHierarchy::GetFlattenedNodes

(

NodeVector &

nodeVector

)

const

Retrieve a flat vector of the ndoes in the hierarchy.

Parameters

nodeVector

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

Definition at line 404 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::MCParticle * lar_content::LArHierarchyHelper::MCHierarchy::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 948 of file LArHierarchyHelper.h.

{
    return m_pNeutrino;
}

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

inline

Retrieve the root nodes in this hierarchy.

Returns

The root nodes in this hierarchy

Definition at line 955 of file LArHierarchyHelper.h.

{
    return m_rootNodes;
}

void lar_content::LArHierarchyHelper::MCHierarchy::InterpretHierarchy	(	const pandora::MCParticle *const	pRoot,
		pandora::MCParticleList &	leadingParticles,
		pandora::MCParticleList &	childParticles,
		const float	cosAngleTolerance
	)		const

Interpret the hierarchy below a particular particle to determine if and how it should be folded. Folded particles are added to the leadingParticles list and child particles are added to the childParticles list.

Parameters

pRoot	The root of the hierarchy to interpret
leadingParticles	The output list of particles that should be folded into the root particle
childParticles	The output list of particles that should be considered children of the folded particle
cosAngleTolerance	The cosine of the maximum angle for which trajectories are considered continuous

Definition at line 249 of file LArHierarchyHelper.cc.

{
    leadingParticles.emplace_back(pRoot);
    MCParticleList foldCandidates, childCandidates;
    const MCParticleList &children{pRoot->GetDaughterList()};
    for (const MCParticle *pMCParticle : children)
    {
        const LArMCParticle *pLArMCParticle{dynamic_cast<const LArMCParticle *>(pMCParticle)};
        if (!pLArMCParticle)
            continue;
        if (LArMCParticleHelper::IsInelasticScatter(pMCParticle) || LArMCParticleHelper::IsElasticScatter(pMCParticle))
        {
            // Elastic and inelastic scattering can either lead to folding, distinct nodes or disposable hits, all other processes
            // are either distinct nodes, or disposable
            if (pMCParticle->GetParticleId() == pRoot->GetParticleId())
                foldCandidates.emplace_back(pMCParticle);
            else
                childCandidates.emplace_back(pMCParticle);
        }
        else if (!m_recoCriteria.m_removeNeutrons || (m_recoCriteria.m_removeNeutrons && pLArMCParticle->GetProcess() != MC_PROC_N_CAPTURE))
        {
            // Non-scattering process particles become leading candidates unless it's neutron capture and we're removing neutrons
            childCandidates.emplace_back(pMCParticle);
        }
    }
    const MCParticle *pBestFoldCandidate{nullptr};
    float bestDp{std::numeric_limits<float>::max()};
    for (const MCParticle *pMCParticle : foldCandidates)
    {
        if (foldCandidates.size() == 1)
        {
            // No alternative options, so this is either the best folding option by default, or a sufficiently large scatter to
            // treat as a new particle for reconstruction purposes
            if (LArMCParticleHelper::AreTopologicallyContinuous(pRoot, pMCParticle, cosAngleTolerance))
                pBestFoldCandidate = pMCParticle;
            else
                childCandidates.emplace_back(pMCParticle);
        }
        else
        {
            // Assess which, if any, of the children might be a continuation of the trajectory, otherwise move to child candidates
            if (LArMCParticleHelper::AreTopologicallyContinuous(pRoot, pMCParticle, cosAngleTolerance))
            {
                const float dp{pRoot->GetMomentum().GetMagnitude() - pMCParticle->GetMomentum().GetMagnitude()};
                if (dp < bestDp)
                {
                    pBestFoldCandidate = pMCParticle;
                    bestDp = dp;
                }
            }
            else
            {
                childCandidates.emplace_back(pMCParticle);
            }
        }
    }
    if (pBestFoldCandidate)
    {
        leadingParticles.emplace_back(pBestFoldCandidate);
        // Having found a particle to fold back at this level, continue to explore its downstream hierarchy for further folding
        // opportunities and make their respective children leading particles for the folded node we are creating
        this->CollectContinuations(pBestFoldCandidate, leadingParticles, childCandidates, cosAngleTolerance);
    }
    for (const MCParticle *pMCParticle : childCandidates)
    {
        // Consider if the child particle will produce enough downstream hits to warrant inclusion
        if (this->IsReconstructable(pMCParticle))
            childParticles.emplace_back(pMCParticle);
        else
        {
            MCParticleList localHierarchy{pMCParticle};
            CaloHitList localHits;
            LArMCParticleHelper::GetAllDescendentMCParticles(pMCParticle, localHierarchy);
            for (const MCParticle *pLocalMCParticle : localHierarchy)
            {
                if (m_mcToHitsMap.find(pLocalMCParticle) != m_mcToHitsMap.end())
                {
                    const CaloHitList &caloHits(m_mcToHitsMap.at(pLocalMCParticle));
                    localHits.insert(localHits.begin(), caloHits.begin(), caloHits.end());
                }
            }
            if (this->IsReconstructable(localHits))
                childParticles.emplace_back(pMCParticle);
        }
    }
}

bool lar_content::LArHierarchyHelper::MCHierarchy::IsNeutrinoHierarchy ( ) const

inline

Check if this is a neutrino hierarchy.

Returns

Whether or not this is a neutrino hierarchy.

Definition at line 962 of file LArHierarchyHelper.h.

{
    return m_pNeutrino != nullptr;
}

bool lar_content::LArHierarchyHelper::MCHierarchy::IsReconstructable ( const pandora::MCParticle *  pMCParticle ) const

private

Checks if an individual particle meets reconstructability criteria.

Parameters

pMCParticle

The MC particle to assess

Returns

Whether or not the MC particle meets reconstructability criteria

Definition at line 445 of file LArHierarchyHelper.cc.

{
    if (m_mcToHitsMap.find(pMCParticle) != m_mcToHitsMap.end())
    {
        unsigned int nHitsU{0}, nHitsV{0}, nHitsW{0};
        for (const CaloHit *pCaloHit : m_mcToHitsMap.at(pMCParticle))
        {
            const HitType view{pCaloHit->GetHitType()};
            if (view == TPC_VIEW_U)
                ++nHitsU;
            else if (view == TPC_VIEW_V)
                ++nHitsV;
            else if (view == TPC_VIEW_W)
                ++nHitsW;
        }
        const unsigned int nHits{nHitsU + nHitsV + nHitsW};
        unsigned int nGoodViews{0};
        nGoodViews += nHitsU >= m_recoCriteria.m_minHitsForGoodView ? 1 : 0;
        nGoodViews += nHitsV >= m_recoCriteria.m_minHitsForGoodView ? 1 : 0;
        nGoodViews += nHitsW >= m_recoCriteria.m_minHitsForGoodView ? 1 : 0;

        return nHits >= m_recoCriteria.m_minHits && nGoodViews >= m_recoCriteria.m_minGoodViews;
    }

    return false;
}

bool lar_content::LArHierarchyHelper::MCHierarchy::IsReconstructable ( const pandora::CaloHitList &  caloHits ) const

private

Checks if a set of hits meet reconstructability criteria.

Parameters

caloHits

The calo hits to assess

Returns

Whether or not the hits meet reconstructability criteria

bool lar_content::LArHierarchyHelper::MCHierarchy::IsTestBeamHierarchy ( ) const

inline

Check if this is a test beam hierarchy.

Returns

Whether or not this is a test beam hierarchy.

Definition at line 969 of file LArHierarchyHelper.h.

{
    return m_pNeutrino == nullptr;
}

void lar_content::LArHierarchyHelper::MCHierarchy::RegisterNode

(

const Node *

pNode

)

Register a node with the hierarchy.

Parameters

pNode

The node to register

Definition at line 426 of file LArHierarchyHelper.cc.

{
    m_nodeToIdMap.insert(std::make_pair(pNode, m_nextNodeId));
    ++m_nextNodeId;
}

const std::string lar_content::LArHierarchyHelper::MCHierarchy::ToString

(

)

const

Produce a string representation of the hierarchy.

Returns

The string representation of the hierarchy

Definition at line 434 of file LArHierarchyHelper.cc.

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

    return str;
}

Member Data Documentation

std::map<const pandora::MCParticle *, pandora::CaloHitList> lar_content::LArHierarchyHelper::MCHierarchy::m_mcToHitsMap

private

The map between MC particles and calo hits.

Definition at line 418 of file LArHierarchyHelper.h.

int lar_content::LArHierarchyHelper::MCHierarchy::m_nextNodeId

private

The ID to use for the next node.

Definition at line 420 of file LArHierarchyHelper.h.

std::map<const Node *, int> lar_content::LArHierarchyHelper::MCHierarchy::m_nodeToIdMap

private

A map from nodes to unique ids.

Definition at line 419 of file LArHierarchyHelper.h.

const pandora::MCParticle* lar_content::LArHierarchyHelper::MCHierarchy::m_pNeutrino

private

The incident neutrino, if it exists.

Definition at line 417 of file LArHierarchyHelper.h.

ReconstructabilityCriteria lar_content::LArHierarchyHelper::MCHierarchy::m_recoCriteria

private

The criteria used to determine if the node is reconstructable.

Definition at line 416 of file LArHierarchyHelper.h.

NodeVector lar_content::LArHierarchyHelper::MCHierarchy::m_rootNodes

private

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

Definition at line 415 of file LArHierarchyHelper.h.

---

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

• LArHierarchyHelper.h
• LArHierarchyHelper.cc