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
typedef std::map< const pandora::MCParticle *, NodeVector >	MCNodeVectorMap

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 &	GetInteractions (const pandora::MCParticle *pRoot) const
	Retrieve the root nodes in this hierarchy. More...
void	GetRootMCParticles (pandora::MCParticleList &rootMCParticles) const
	Retrieve the root MC particles of the interaction hierarchies. More...
void	GetFlattenedNodes (const pandora::MCParticle *const pRoot, 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...

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
MCNodeVectorMap	m_interactions
	Map from incident particles (e.g. neutrino) to primaries. More...
ReconstructabilityCriteria	m_recoCriteria
	The criteria used to determine if the node is reconstructable. 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 90 of file LArHierarchyHelper.h.

Member Typedef Documentation

typedef std::map<const pandora::MCParticle *, NodeVector> lar_content::LArHierarchyHelper::MCHierarchy::MCNodeVectorMap

Definition at line 129 of file LArHierarchyHelper.h.

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

Definition at line 128 of file LArHierarchyHelper.h.

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

Definition at line 126 of file LArHierarchyHelper.h.

Constructor & Destructor Documentation

lar_content::LArHierarchyHelper::MCHierarchy::MCHierarchy

(

)

Default constructor.

Definition at line 80 of file LArHierarchyHelper.cc.

                                           :
    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 87 of file LArHierarchyHelper.cc.

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

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

virtual

Destructor.

Definition at line 95 of file LArHierarchyHelper.cc.

References m_interactions.

{
    for (const auto &[pRoot, nodeVector] : m_interactions)
    {
        (void)pRoot;
        for (const Node *pNode : nodeVector)
            delete pNode;
    }
    m_interactions.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 379 of file LArHierarchyHelper.cc.

References lar_content::LArMCParticleHelper::AreTopologicallyContinuous(), lar_content::LArMCParticleHelper::IsElasticScatter(), lar_content::LArMCParticleHelper::IsInelasticScatter(), m_recoCriteria, lar_content::LArHierarchyHelper::MCHierarchy::ReconstructabilityCriteria::m_removeNeutrons, and lar_content::MC_PROC_N_CAPTURE.

Referenced by InterpretHierarchy().

{
    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 108 of file LArHierarchyHelper.cc.

References util::abs(), lar_content::LArMCParticleHelper::GetAllDescendentMCParticles(), lar_content::LArHierarchyHelper::MCHierarchy::Node::GetLeadingMCParticle(), lar_content::LArHierarchyHelper::GetMCPrimaries(), InterpretHierarchy(), lar_content::LArHierarchyHelper::FoldingParameters::m_cosAngleTolerance, lar_content::LArHierarchyHelper::FoldingParameters::m_foldDynamic, lar_content::LArHierarchyHelper::FoldingParameters::m_foldToLeadingShowers, lar_content::LArHierarchyHelper::FoldingParameters::m_foldToTier, m_interactions, m_mcToHitsMap, m_recoCriteria, lar_content::LArHierarchyHelper::MCHierarchy::ReconstructabilityCriteria::m_removeNeutrons, lar_content::LArHierarchyHelper::FoldingParameters::m_tier, lar_content::LArHierarchyHelper::MCHierarchy::Node::SetLeadingLepton(), and lar_content::LArMCParticleHelper::SortByMomentum().

Referenced by lar_content::LArHierarchyHelper::FillMCHierarchy().

{
    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 &)
        {
        }
    }

    MCParticleList rootNodes;
    for (const MCParticle *pMCParticle : mcParticleList)
    {
        const MCParticleList &parentList{pMCParticle->GetParentList()};
        if (parentList.empty())
        {
            rootNodes.emplace_back(pMCParticle);
        }
    }

    for (const MCParticle *pRoot : rootNodes)
    {
        MCParticleSet primarySet;
        LArHierarchyHelper::GetMCPrimaries(pRoot, 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_interactions[pRoot].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_interactions[pRoot].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_interactions[pRoot].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_interactions[pRoot].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_interactions[pRoot])
        {
            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	(	const pandora::MCParticle *const	pRoot,
		NodeVector &	nodeVector
	)		const

Retrieve a flat vector of the ndoes in the hierarchy.

Parameters

pRoot	The root MC particle for an interaction
nodeVector	The output vector for the nodes in the hierarchy in breadth first order

Definition at line 444 of file LArHierarchyHelper.cc.

References m_interactions.

Referenced by lar_content::LArHierarchyHelper::MatchInfo::Match(), and lar_content::HierarchyMonitoringAlgorithm::Run().

{
    NodeList queue;
    for (const Node *pNode : m_interactions.at(pRoot))
    {
        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 LArHierarchyHelper::MCHierarchy::NodeVector & lar_content::LArHierarchyHelper::MCHierarchy::GetInteractions

(

const pandora::MCParticle *

pRoot

)

const

Retrieve the root nodes in this hierarchy.

Parameters

pRoot

The root of the interaction hierarchy

Returns

The primary nodes in the requested interaction hierarchy

Definition at line 271 of file LArHierarchyHelper.cc.

References m_interactions.

{
    if (m_interactions.find(pRoot) == m_interactions.end())
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    return m_interactions.at(pRoot);
}

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

(

)

const

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)

void lar_content::LArHierarchyHelper::MCHierarchy::GetRootMCParticles

(

pandora::MCParticleList &

rootMCParticles

)

const

Retrieve the root MC particles of the interaction hierarchies.

Parameters

rootMCParticles

The output list of root MC particles

Definition at line 281 of file LArHierarchyHelper.cc.

References m_interactions.

Referenced by lar_content::LArHierarchyHelper::MatchInfo::Match(), lar_content::LArHierarchyHelper::MatchInfo::Print(), and lar_content::HierarchyMonitoringAlgorithm::Run().

{
    for (auto iter = m_interactions.begin(); iter != m_interactions.end(); ++iter)
        rootMCParticles.emplace_back(iter->first);
}

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 289 of file LArHierarchyHelper.cc.

References lar_content::LArMCParticleHelper::AreTopologicallyContinuous(), CollectContinuations(), lar_content::LArMCParticleHelper::GetAllDescendentMCParticles(), lar_content::LArMCParticleHelper::IsElasticScatter(), lar_content::LArMCParticleHelper::IsInelasticScatter(), IsReconstructable(), m_mcToHitsMap, m_recoCriteria, lar_content::LArHierarchyHelper::MCHierarchy::ReconstructabilityCriteria::m_removeNeutrons, and lar_content::MC_PROC_N_CAPTURE.

Referenced by FillHierarchy().

{
    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::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 494 of file LArHierarchyHelper.cc.

References m_mcToHitsMap, lar_content::LArHierarchyHelper::MCHierarchy::ReconstructabilityCriteria::m_minGoodViews, lar_content::LArHierarchyHelper::MCHierarchy::ReconstructabilityCriteria::m_minHits, lar_content::LArHierarchyHelper::MCHierarchy::ReconstructabilityCriteria::m_minHitsForGoodView, m_recoCriteria, lar_content::LArHierarchyHelper::MCHierarchy::Node::Node(), and lar_content::LArMCParticleHelper::SortByMomentum().

Referenced by InterpretHierarchy().

{
    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

void lar_content::LArHierarchyHelper::MCHierarchy::RegisterNode

(

const Node *

pNode

)

Register a node with the hierarchy.

Parameters

pNode

The node to register

Definition at line 466 of file LArHierarchyHelper.cc.

References m_nextNodeId, and m_nodeToIdMap.

{
    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 474 of file LArHierarchyHelper.cc.

References m_interactions, and util::to_string().

Referenced by lar_content::HierarchyMonitoringAlgorithm::Run().

{
    std::string str;
    for (const auto &[pRoot, nodeVector] : m_interactions)
    {
        const LArMCParticle *const pLArRoot{dynamic_cast<const LArMCParticle *const>(pRoot)};
        if (pLArRoot)
            str += "=== MC Interaction : PDG " + std::to_string(pLArRoot->GetParticleId()) +
                " Energy: " + std::to_string(pLArRoot->GetEnergy()) + " Nuance: " + std::to_string(pLArRoot->GetNuanceCode()) + "\n";
        else
            str += "=== MC Interaction : PDG " + std::to_string(pRoot->GetParticleId()) + " Energy: " + std::to_string(pRoot->GetEnergy()) + "\n";
        for (const Node *pNode : nodeVector)
            str += "   " + pNode->ToString("") + "\n";
    }

    return str;
}

Member Data Documentation

MCNodeVectorMap lar_content::LArHierarchyHelper::MCHierarchy::m_interactions

private

Map from incident particles (e.g. neutrino) to primaries.

Definition at line 414 of file LArHierarchyHelper.h.

Referenced by FillHierarchy(), lar_content::LArHierarchyHelper::RecoHierarchy::FillHierarchy(), GetFlattenedNodes(), lar_content::LArHierarchyHelper::RecoHierarchy::GetFlattenedNodes(), GetInteractions(), lar_content::LArHierarchyHelper::RecoHierarchy::GetInteractions(), GetRootMCParticles(), lar_content::LArHierarchyHelper::RecoHierarchy::GetRootPfos(), ToString(), lar_content::LArHierarchyHelper::RecoHierarchy::ToString(), ~MCHierarchy(), and lar_content::LArHierarchyHelper::RecoHierarchy::~RecoHierarchy().

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 416 of file LArHierarchyHelper.h.

Referenced by FillHierarchy(), InterpretHierarchy(), and IsReconstructable().

int lar_content::LArHierarchyHelper::MCHierarchy::m_nextNodeId

private

The ID to use for the next node.

Definition at line 418 of file LArHierarchyHelper.h.

Referenced by RegisterNode().

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

private

A map from nodes to unique ids.

Definition at line 417 of file LArHierarchyHelper.h.

Referenced by RegisterNode().

ReconstructabilityCriteria lar_content::LArHierarchyHelper::MCHierarchy::m_recoCriteria

private

The criteria used to determine if the node is reconstructable.

Definition at line 415 of file LArHierarchyHelper.h.

Referenced by CollectContinuations(), FillHierarchy(), InterpretHierarchy(), and IsReconstructable().

---

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

• larpandoracontent/v04_14_00/source/larpandoracontent/LArHelpers/LArHierarchyHelper.h
• larpandoracontent/v04_14_00/source/larpandoracontent/LArHelpers/LArHierarchyHelper.cc