DLCheatHierarchyTool to calculate variables related to the initial shower region. More...

#include "DLCheatHierarchyTool.h"

Inheritance diagram for lar_dl_content::DLCheatHierarchyTool:

Public Types
typedef std::map< const pandora::ParticleFlowObject , const pandora::MCParticle >	PfoToMCParticleMap

typedef std::map< const pandora::ParticleFlowObject , std::pair< const pandora::ParticleFlowObject , int > >	ChildToParentPfoMap

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

pandora::StatusCode	Run (const PfoToMCParticleMap &pfoToMCParticleMap, const ChildToParentPfoMap &childToParentPfoMap, const HierarchyPfo &parentPfo, const HierarchyPfo &childPfo, bool &isTrueLink, bool &trueParentOrientation, bool &trueChildOrientation)

pandora::StatusCode	Run (const PfoToMCParticleMap &pfoToMCParticleMap, const ChildToParentPfoMap &childToParentPfoMap, const pandora::ParticleFlowObject *const pNeutrinoPfo, const HierarchyPfo &childPfo, bool &isTrueLink, bool &trueChildOrientation)

void	FillHierarchyMap (const pandora::Algorithm *const pAlgorithm, PfoToMCParticleMap &pfoToMCParticleMap, ChildToParentPfoMap &childToParentPfoMap) const
	Determine the true child -> parent pfo visible matches, filling the pfo->MCParticle matching map in the process. More...

pandora::StatusCode	IsNeutronChild (const pandora::ParticleFlowObject *const pPfo, const PfoToMCParticleMap &pfoToMCParticleMap, bool &isNeutronChild) const
	Whether the true invisible parent of a particle is a neutron. More...

Private Types
typedef std::map< const pandora::MCParticle , const pandora::MCParticle >	MCToMCMap

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

bool	IsUpstreamTrueVertex (const PfoToMCParticleMap &pfoToMCParticleMap, const pandora::ParticleFlowObject *const pPfo, const pandora::CartesianVector &upstreamVertex, const pandora::CartesianVector &downstreamVertex)
	Whether the true startpoint of the particle is in the upstream position (i.e. the endpoint closest to the neutrino vertex) More...

bool	GetMCParticleList (const pandora::Algorithm const pAlgorithm, const pandora::MCParticleList &pMCParticleList) const
	Get the MCParticle list from Pandora. More...

bool	GetNeutrinoPfo (const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject &pNeutrinoPfo) const
	Get the neutrino pfo. More...

void	MatchPFParticles (const pandora::Algorithm *const pAlgorithm, PfoToMCParticleMap &pfoToMCParticleMap) const
	Perform the pfo->MCParticle matching, folding back EM shower hierarchies. More...

float	GetNSpacepoints (const pandora::ParticleFlowObject *const pPfo) const
	Get the number of 3D hits owned by a pfo. More...

bool	IsEMParticle (const pandora::MCParticle *const pMCParticle) const
	Whether a MCParticle is an electron or photon. More...

const pandora::MCParticle *	GetLeadEMParticle (const pandora::MCParticle *const pMCParticle) const
	Get the leading EM Particle in an EM MCParticle hierarchy. More...

float	SumEnergy (const pandora::CaloHitList &caloHitList) const
	Sum the 'energy' of the W hits in an input CaloHitList. More...

void	GetVisibleMCHierarchy (const PfoToMCParticleMap &pfoToMCParticleMap, MCToMCMap &childToParentMCMap) const
	Determine the true child->parent MCParticle visible matches. More...

void	GetVisiblePfoHierarchy (const pandora::ParticleFlowObject *const pNeutrinoPfo, const PfoToMCParticleMap &pfoToMCParticleMap, const MCToMCMap &childToParentMCMap, ChildToParentPfoMap &childToParentPfoMap) const
	Determine the true child->parent pfo visible matches. More...

void	BuildSplitHierarchy (const std::pair< const pandora::MCParticle *, pandora::PfoList > &splitPfo, ChildToParentPfoMap &childToParentPfoMap) const
	Determine the 'internal' hierachy of reconstructed particles that match to the same MCParticle i.e. split particles. More...

float	GetClosestDistance (const pandora::ParticleFlowObject const pPfo1, const pandora::ParticleFlowObject const pPfo2) const
	Determine the closest distance between two pfos. More...

const pandora::ParticleFlowObject *	BestParentInSplitHierarchy (const pandora::ParticleFlowObject *const pChildPfo, const pandora::PfoList &splitParticle) const
	In cases in which the true parent pfo is ambiguous (because the parent particle has been split), find the best parent based on proximity. More...

void	AssignGeneration (const pandora::ParticleFlowObject *const pParentPfo, const int generationToFind, ChildToParentPfoMap &childToParentPfoMap) const
	Find the children of an input parent pfo in the ChildToParentPfoMap, and assign their generation. More...

Private Attributes
std::string	m_mcParticleListName
	the MCParticle list name More...

std::string	m_neutrinoPfoListName
	the neutrino pfo list name More...

pandora::StringVector	m_pfoListNames
	the vector of pfo list names More...

Detailed Description

DLCheatHierarchyTool to calculate variables related to the initial shower region.

Definition at line 25 of file DLCheatHierarchyTool.h.

Member Typedef Documentation

typedef std::map<const pandora::ParticleFlowObject *, std::pair<const pandora::ParticleFlowObject *, int> > lar_dl_content::DLCheatHierarchyTool::ChildToParentPfoMap

Definition at line 29 of file DLCheatHierarchyTool.h.

typedef std::map<const pandora::MCParticle *, const pandora::MCParticle *> lar_dl_content::DLCheatHierarchyTool::MCToMCMap

private

Definition at line 66 of file DLCheatHierarchyTool.h.

typedef std::map<const pandora::ParticleFlowObject *, const pandora::MCParticle *> lar_dl_content::DLCheatHierarchyTool::PfoToMCParticleMap

Definition at line 28 of file DLCheatHierarchyTool.h.

Constructor & Destructor Documentation

lar_dl_content::DLCheatHierarchyTool::DLCheatHierarchyTool ( )

Default constructor.

Definition at line 26 of file DLCheatHierarchyTool.cc.

                                            :
     m_mcParticleListName("Input"),
     m_neutrinoPfoListName("NeutrinoParticles3D"),
     m_pfoListNames({"TrackParticles3D", "ShowerParticles3D"})
 {
 }

Member Function Documentation

void lar_dl_content::DLCheatHierarchyTool::AssignGeneration	(	const pandora::ParticleFlowObject *const	pParentPfo,
		const int	generationToFind,
		ChildToParentPfoMap &	childToParentPfoMap
	)		const

private

Find the children of an input parent pfo in the ChildToParentPfoMap, and assign their generation.

Parameters

pParentPfo	a pointer to the parent pfo
generationToFind	the generation to assign
childToParentPfoMap	the true child->parent pfo visible match map to modify

Definition at line 521 of file DLCheatHierarchyTool.cc.

Referenced by GetVisiblePfoHierarchy().

 {
     // Don't want to use a reference here
     for (ChildToParentPfoMap::value_type &entry : childToParentPfoMap)
     {
         const ParticleFlowObject *const pThisPfo(entry.first);
         const ParticleFlowObject *const pThisParent(entry.second.first);
 
         if (pParentPfo == pThisParent)
         {
             entry.second.second = generationToFind;
             this->AssignGeneration(pThisPfo, (generationToFind + 1), childToParentPfoMap);
         }
     }
 }

const ParticleFlowObject * lar_dl_content::DLCheatHierarchyTool::BestParentInSplitHierarchy	(	const pandora::ParticleFlowObject *const	pChildPfo,
		const pandora::PfoList &	splitParticle
	)		const

private

In cases in which the true parent pfo is ambiguous (because the parent particle has been split), find the best parent based on proximity.

Parameters

pChildPfo	a pointer to the child particle
splitParticle	the list of pfos forming the split particle

Returns: the best parent pfo

Definition at line 494 of file DLCheatHierarchyTool.cc.

References GetClosestDistance().

Referenced by GetVisiblePfoHierarchy().

 {
     float closestSep = std::numeric_limits<float>::max();
     const ParticleFlowObject *pParentPfo(nullptr);
 
     for (const ParticleFlowObject *const pPotentialParent : splitParticle)
     {
         float thisSep(this->GetClosestDistance(pChildPfo, pPotentialParent));
 
         if (thisSep < closestSep)
         {
             closestSep = thisSep;
             pParentPfo = pPotentialParent;
         }
     }
 
     if (!pParentPfo)
     {
         std::cout << "No closest Pfo?" << std::endl;
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
     }
 
     return pParentPfo;
 }

void lar_dl_content::DLCheatHierarchyTool::BuildSplitHierarchy	(	const std::pair< const pandora::MCParticle *, pandora::PfoList > &	splitPfo,
		ChildToParentPfoMap &	childToParentPfoMap
	)		const

private

Determine the 'internal' hierachy of reconstructed particles that match to the same MCParticle i.e. split particles.

Parameters

splitPfo	the (MCParticle, list of matched pfos) pair
childToParentPfoMap	the true child->parent pfo visible match map to fill

Definition at line 433 of file DLCheatHierarchyTool.cc.

References GetClosestDistance().

Referenced by GetVisiblePfoHierarchy().

 {
     // Order segments wrt distance to the true vertex
     std::vector<std::pair<const ParticleFlowObject *, float>> pfoComponents;
 
     for (const ParticleFlowObject *const pSplitPfo : splitPfo.second)
     {
         ClusterList clusterList;
         LArPfoHelper::GetThreeDClusterList(pSplitPfo, clusterList);
 
         if (clusterList.empty())
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         pfoComponents.emplace_back(std::make_pair(pSplitPfo, LArClusterHelper::GetClosestDistance(splitPfo.first->GetVertex(), clusterList)));
     }
 
     std::sort(pfoComponents.begin(), pfoComponents.end(),
         [](const std::pair<const ParticleFlowObject *, float> &a, const std::pair<const ParticleFlowObject *, float> &b)
         { return a.second < b.second; });
 
     // Now build pfo hierarchy, assuming closest is the leading pfo
     childToParentPfoMap[pfoComponents.at(1).first] = std::make_pair(pfoComponents.at(0).first, 0);
 
     for (unsigned int i = 2; i < pfoComponents.size(); ++i)
     {
         const ParticleFlowObject *const pChildPfo(pfoComponents.at(i).first);
         double closestSep = std::numeric_limits<double>::max();
         const ParticleFlowObject *pParentPfo(nullptr);
 
         for (unsigned int j = 0; j < i; ++j)
         {
             const ParticleFlowObject *const pPotentialParentPfo(pfoComponents.at(j).first);
             const float thisSep(this->GetClosestDistance(pChildPfo, pPotentialParentPfo));
 
             if (thisSep < closestSep)
             {
                 closestSep = thisSep;
                 pParentPfo = pPotentialParentPfo;
             }
         }
 
         if (!pParentPfo)
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         childToParentPfoMap[pChildPfo] = std::make_pair(pParentPfo, 0); // Temporarily set generation to 0
     }
 }

void lar_dl_content::DLCheatHierarchyTool::FillHierarchyMap	(	const pandora::Algorithm *const	pAlgorithm,
		PfoToMCParticleMap &	pfoToMCParticleMap,
		ChildToParentPfoMap &	childToParentPfoMap
	)		const

Determine the true child -> parent pfo visible matches, filling the pfo->MCParticle matching map in the process.

Parameters

pAlgorithm	a pointer to the pandora algorithm
pfoToMCParticleMap	the pfo->MCParticle matching map to fill
childToParentPfoMap	the pfo->(parentPfo, generation) map to fill

Definition at line 120 of file DLCheatHierarchyTool.cc.

References GetMCParticleList(), GetNeutrinoPfo(), GetVisibleMCHierarchy(), GetVisiblePfoHierarchy(), and MatchPFParticles().

Referenced by lar_dl_content::DLNeutrinoHierarchyAlgorithm::Run().

 {
     pfoToMCParticleMap.clear();
     childToParentPfoMap.clear();
 
     // Get MCParticles
     const MCParticleList *pMCParticleList(nullptr);
     if (!this->GetMCParticleList(pAlgorithm, pMCParticleList))
         return;
 
     // Get reconstructed neutrino
     const ParticleFlowObject *pNeutrinoPfo(nullptr);
     if (!this->GetNeutrinoPfo(pAlgorithm, pNeutrinoPfo))
         return;
 
     // Match our PFPs to our MCParticles
     this->MatchPFParticles(pAlgorithm, pfoToMCParticleMap);
 
     // Do MCParticle visible hierarchy building
     MCToMCMap childToParentMCMap;
     this->GetVisibleMCHierarchy(pfoToMCParticleMap, childToParentMCMap);
 
     // Do Pfo visible hierarchy building
     this->GetVisiblePfoHierarchy(pNeutrinoPfo, pfoToMCParticleMap, childToParentMCMap, childToParentPfoMap);
 }

float lar_dl_content::DLCheatHierarchyTool::GetClosestDistance	(	const pandora::ParticleFlowObject *const	pPfo1,
		const pandora::ParticleFlowObject *const	pPfo2
	)		const

private

Determine the closest distance between two pfos.

Parameters

pPfo1	a pointer to one pfo
pPfo2	a pointer to the other pfo

Returns: the closest distance between the two pfos

Definition at line 483 of file DLCheatHierarchyTool.cc.

Referenced by BestParentInSplitHierarchy(), and BuildSplitHierarchy().

 {
     ClusterList clusterList1, clusterList2;
     LArPfoHelper::GetThreeDClusterList(pPfo1, clusterList1);
     LArPfoHelper::GetThreeDClusterList(pPfo2, clusterList2);
 
     return LArClusterHelper::GetClosestDistance(clusterList1, clusterList2);
 }

const MCParticle * lar_dl_content::DLCheatHierarchyTool::GetLeadEMParticle ( const pandora::MCParticle *const pMCParticle ) const

private

Get the leading EM Particle in an EM MCParticle hierarchy.

Parameters

pMCParticle a pointer to the input EM MCParticle

Returns: the leading EM Particle in the EM MCParticle hierarchy

Definition at line 286 of file DLCheatHierarchyTool.cc.

References IsEMParticle().

Referenced by MatchPFParticles().

 {
     if (!this->IsEMParticle(pMCParticle))
         throw StatusCodeException(STATUS_CODE_NOT_ALLOWED);
 
     const MCParticle *pThisMCParticle(pMCParticle);
     const MCParticle *pParentMCParticle(pMCParticle);
 
     while (this->IsEMParticle(pParentMCParticle))
     {
         const MCParticleList &parentList(pThisMCParticle->GetParentList());
 
         if (parentList.size() != 1)
         {
             std::cout << "EM shower has no parent?" << std::endl;
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
         }
 
         pParentMCParticle = *parentList.begin();
 
         if (this->IsEMParticle(pParentMCParticle))
             pThisMCParticle = pParentMCParticle;
     }
 
     return pThisMCParticle;
 }

bool lar_dl_content::DLCheatHierarchyTool::GetMCParticleList	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::MCParticleList *&	pMCParticleList
	)		const

private

Get the MCParticle list from Pandora.

Parameters

pAlgorithm	a pointer to the pandora algorithm
pMCParticleList	a pointer to the MCParticle list

Returns: whether the MCParticle list could be set and is filled

Definition at line 149 of file DLCheatHierarchyTool.cc.

References m_mcParticleListName.

Referenced by FillHierarchyMap().

 {
     if (PandoraContentApi::GetList(*pAlgorithm, m_mcParticleListName, pMCParticleList) != STATUS_CODE_SUCCESS)
         return false;
 
     if (!pMCParticleList || pMCParticleList->empty())
         return false;
 
     return true;
 }

bool lar_dl_content::DLCheatHierarchyTool::GetNeutrinoPfo	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *&	pNeutrinoPfo
	)		const

private

Get the neutrino pfo.

Parameters

pAlgorithm	a pointer to the pandora algorithm
pNeutrinoPfo	a pointer to the neutrino pfo

Returns: whether the neutrino pfo could be found

Definition at line 162 of file DLCheatHierarchyTool.cc.

References m_neutrinoPfoListName.

Referenced by FillHierarchyMap().

 {
     const PfoList *pPfoList = nullptr;
 
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*pAlgorithm, m_neutrinoPfoListName, pPfoList));
 
     if (!pPfoList || pPfoList->empty())
         return false;
 
     // ATTN Enforces that only one pfo, of neutrino-type, be in the specified input list
     pNeutrinoPfo = (1 == pPfoList->size()) ? *(pPfoList->begin()) : nullptr;
 
     if (!pNeutrinoPfo || !LArPfoHelper::IsNeutrino(pNeutrinoPfo))
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     return true;
 }

float lar_dl_content::DLCheatHierarchyTool::GetNSpacepoints ( const pandora::ParticleFlowObject *const pPfo ) const

private

Get the number of 3D hits owned by a pfo.

Parameters

pPfo	a pointer to the input pfo

Definition at line 264 of file DLCheatHierarchyTool.cc.

Referenced by MatchPFParticles().

 {
     ClusterList clusterList3D;
     LArPfoHelper::GetThreeDClusterList(pPfo, clusterList3D);
 
     int total3DHits(0);
 
     for (const Cluster *const pCluster3D : clusterList3D)
         total3DHits += pCluster3D->GetNCaloHits();
 
     return total3DHits;
 }

void lar_dl_content::DLCheatHierarchyTool::GetVisibleMCHierarchy	(	const PfoToMCParticleMap &	pfoToMCParticleMap,
		MCToMCMap &	childToParentMCMap
	)		const

private

Determine the true child->parent MCParticle visible matches.

Parameters

pfoToMCParticleMap	the pfo->MCParticle matching map
childToParentMCMap	the true child->parent MCParticle visible match map to fill

Definition at line 330 of file DLCheatHierarchyTool.cc.

Referenced by FillHierarchyMap().

 {
     MCParticleList reconstructedMCList;
 
     for (const auto &entry : pfoToMCParticleMap)
     {
         if (std::find(reconstructedMCList.begin(), reconstructedMCList.end(), entry.second) == reconstructedMCList.end())
             reconstructedMCList.emplace_back(entry.second);
     }
 
     for (const MCParticle *const pMCParticle : reconstructedMCList)
     {
         bool foundParent(false);
         const MCParticle *pThisMCParticle(pMCParticle);
         const MCParticle *pParentMCParticle(nullptr);
 
         while (!foundParent)
         {
             const MCParticleList &parentList(pThisMCParticle->GetParentList());
 
             if (parentList.size() != 1)
             {
                 std::cout << "No MCParent for MCParticle" << std::endl;
                 throw StatusCodeException(STATUS_CODE_NOT_FOUND);
             }
 
             pParentMCParticle = *parentList.begin();
 
             foundParent = (LArMCParticleHelper::IsNeutrino(pParentMCParticle) ||
                 (std::find(reconstructedMCList.begin(), reconstructedMCList.end(), pParentMCParticle) != reconstructedMCList.end()));
 
             pThisMCParticle = pParentMCParticle;
         }
 
         childToParentMCMap[pMCParticle] = pParentMCParticle;
     }
 }

void lar_dl_content::DLCheatHierarchyTool::GetVisiblePfoHierarchy	(	const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const PfoToMCParticleMap &	pfoToMCParticleMap,
		const MCToMCMap &	childToParentMCMap,
		ChildToParentPfoMap &	childToParentPfoMap
	)		const

private

Determine the true child->parent pfo visible matches.

Parameters

pNeutrinoPfo	a pointer to the neutrino pfo
pfoToMCParticleMap	the pfo->MCParticle matching map
childToParentMCMap	the true child->parent MCParticle visible match map
childToParentPfoMap	the true child->parent pfo visible match map to fill

Definition at line 370 of file DLCheatHierarchyTool.cc.

References AssignGeneration(), BestParentInSplitHierarchy(), and BuildSplitHierarchy().

Referenced by FillHierarchyMap().

 {
     std::map<const MCParticle *, PfoList> mcParticleToPfoListMap;
 
     for (const auto &entry : pfoToMCParticleMap)
         mcParticleToPfoListMap[entry.second].emplace_back(entry.first);
 
     // First handle any split paricles
     for (const auto &entry : mcParticleToPfoListMap)
     {
         if (entry.second.size() == 1)
             continue;
 
         this->BuildSplitHierarchy(entry, childToParentPfoMap);
     }
 
     // Now assign remaining
     for (const auto &entry : mcParticleToPfoListMap)
     {
         const MCParticle *const pMatchedMCParticle(entry.first);
 
         if (childToParentMCMap.find(pMatchedMCParticle) == childToParentMCMap.end())
         {
             std::cout << "have found a mcparticle with no parent" << std::endl;
             throw StatusCodeException(STATUS_CODE_FAILURE);
         }
 
         const MCParticle *const pMatchedMCParent(childToParentMCMap.at(pMatchedMCParticle));
 
         for (const ParticleFlowObject *const pChildPfo : entry.second)
         {
             // If already assigned, move on
             if (childToParentPfoMap.find(pChildPfo) != childToParentPfoMap.end())
                 continue;
 
             if (LArMCParticleHelper::IsNeutrino(pMatchedMCParent))
             {
                 // If primary, great! Assign neutrino pfo
                 childToParentPfoMap[pChildPfo] = std::make_pair(pNeutrinoPfo, 0);
             }
             else
             {
                 // Else, let's find the parent pfo
                 if (mcParticleToPfoListMap.find(pMatchedMCParent) == mcParticleToPfoListMap.end())
                     throw StatusCodeException(STATUS_CODE_FAILURE);
 
                 const PfoList &parentPfoList(mcParticleToPfoListMap.at(pMatchedMCParent));
 
                 if (parentPfoList.size() == 1)
                     childToParentPfoMap[pChildPfo] = std::make_pair(*parentPfoList.begin(), 0);
                 else
                     childToParentPfoMap[pChildPfo] = std::make_pair(this->BestParentInSplitHierarchy(pChildPfo, parentPfoList), 0);
             }
         }
     }
 
     // Now determine each pfo's generation
     this->AssignGeneration(pNeutrinoPfo, 2, childToParentPfoMap);
 }

bool lar_dl_content::DLCheatHierarchyTool::IsEMParticle ( const pandora::MCParticle *const pMCParticle ) const

private

Whether a MCParticle is an electron or photon.

Parameters

pMCParticle a pointer to the input MCParticle

Definition at line 279 of file DLCheatHierarchyTool.cc.

References util::abs().

Referenced by GetLeadEMParticle(), and MatchPFParticles().

 {
     return ((pMCParticle->GetParticleId() == 22) || (std::abs(pMCParticle->GetParticleId()) == 11));
 }

StatusCode lar_dl_content::DLCheatHierarchyTool::IsNeutronChild	(	const pandora::ParticleFlowObject *const	pPfo,
		const PfoToMCParticleMap &	pfoToMCParticleMap,
		bool &	isNeutronChild
	)		const

Whether the true invisible parent of a particle is a neutron.

Parameters

pPfo	a pointer to the input pfo
pfoToMCParticleMap	the pfo->MCParticle matching map
isNeutronChild	the boolean to fill

Returns: a StatusCode detailing whether an answer could be found

Definition at line 86 of file DLCheatHierarchyTool.cc.

Referenced by lar_dl_content::DLNeutrinoHierarchyAlgorithm::BuildPandoraHierarchy().

 {
     // If we dont know the Pfo->MCParticle match
     if (pfoToMCParticleMap.find(pPfo) == pfoToMCParticleMap.end())
         return STATUS_CODE_NOT_FOUND;
 
     const MCParticleList &parentList(pfoToMCParticleMap.at(pPfo)->GetParentList());
 
     if (parentList.size() != 1)
     {
         std::cout << "No MCParent for MCParticle" << std::endl;
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
     }
 
     isNeutronChild = ((*parentList.begin())->GetParticleId() == 2112);
 
     return STATUS_CODE_SUCCESS;
 }

bool lar_dl_content::DLCheatHierarchyTool::IsUpstreamTrueVertex	(	const PfoToMCParticleMap &	pfoToMCParticleMap,
		const pandora::ParticleFlowObject *const	pPfo,
		const pandora::CartesianVector &	upstreamVertex,
		const pandora::CartesianVector &	downstreamVertex
	)

private

Whether the true startpoint of the particle is in the upstream position (i.e. the endpoint closest to the neutrino vertex)

Parameters

pfoToMCParticleMap	the pfo->MCParticle matching map
pPfo	a pointer to the input pfo
upstreamVertex	the upstream endpoint
downstreamVertex	the downstream endpoint

Returns: whether the true startpoint of the particle is in the upstream position

Definition at line 107 of file DLCheatHierarchyTool.cc.

Referenced by Run().

 {
     const MCParticle *const pMatchedMCParticle(pfoToMCParticleMap.at(pPfo));
 
     const float upstreamSepSq((pMatchedMCParticle->GetVertex() - upstreamVertex).GetMagnitudeSquared());
     const float downstreamSepSq((pMatchedMCParticle->GetVertex() - downstreamVertex).GetMagnitudeSquared());
 
     return (upstreamSepSq < downstreamSepSq);
 }

void lar_dl_content::DLCheatHierarchyTool::MatchPFParticles	(	const pandora::Algorithm *const	pAlgorithm,
		PfoToMCParticleMap &	pfoToMCParticleMap
	)		const

private

Perform the pfo->MCParticle matching, folding back EM shower hierarchies.

Parameters

pAlgorithm	a pointer to the pandora algorithm
pfoToMCParticleMap	the pfo->MCParticle matching map

Definition at line 183 of file DLCheatHierarchyTool.cc.

References f, GetLeadEMParticle(), GetNSpacepoints(), IsEMParticle(), m_pfoListNames, and SumEnergy().

Referenced by FillHierarchyMap().

 {
     for (const std::string &pfoListName : m_pfoListNames)
     {
         const PfoList *pPfoList(nullptr);
 
         if (PandoraContentApi::GetList(*pAlgorithm, pfoListName, pPfoList) != STATUS_CODE_SUCCESS)
             continue;
 
         if (!pPfoList)
             continue;
 
         for (const ParticleFlowObject *pPfo : *pPfoList)
         {
             // Demand that we have 3D hits
             if (this->GetNSpacepoints(pPfo) == 0)
                 continue;
 
             // Fill contribution map
             LArMCParticleHelper::MCContributionMap contributionMap;
 
             for (const HitType hitType : {TPC_VIEW_U, TPC_VIEW_V, TPC_VIEW_W})
             {
                 CaloHitList caloHitList;
                 LArPfoHelper::GetCaloHits(pPfo, hitType, caloHitList);
 
                 for (const CaloHit *const pCaloHit : caloHitList)
                 {
                     try
                     {
                         const MCParticle *pHitMCParticle(MCParticleHelper::GetMainMCParticle(pCaloHit));
 
                         // Sometimes we have to fold back EM shower hierarchies
                         if (this->IsEMParticle(pHitMCParticle))
                             pHitMCParticle = this->GetLeadEMParticle(pHitMCParticle);
 
                         contributionMap[pHitMCParticle].emplace_back(pCaloHit);
                     }
                     catch (...)
                     {
                         continue;
                     }
                 }
             }
 
             // Work out who the match is
             unsigned int highestHit(0);
             float highestEnergy(-1.f);
             const MCParticle *pMatchedMCParticle(nullptr);
 
             for (const auto &entry : contributionMap)
             {
                 if (entry.second.size() > highestHit)
                 {
                     highestHit = entry.second.size();
                     highestEnergy = this->SumEnergy(entry.second);
                     pMatchedMCParticle = entry.first;
                 }
                 else if (entry.second.size() == highestHit)
                 {
                     const float totalEnergy(this->SumEnergy(entry.second));
 
                     if (totalEnergy > highestEnergy)
                     {
                         highestHit = entry.second.size();
                         highestEnergy = totalEnergy;
                         pMatchedMCParticle = entry.first;
                     }
                 }
             }
 
             if (!pMatchedMCParticle)
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             pfoToMCParticleMap[pPfo] = pMatchedMCParticle;
         }
     }
 }

StatusCode lar_dl_content::DLCheatHierarchyTool::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Definition at line 540 of file DLCheatHierarchyTool.cc.

References m_mcParticleListName, m_neutrinoPfoListName, and m_pfoListNames.

 {
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MCParticleListName", m_mcParticleListName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NeutrinoPfoListName", m_neutrinoPfoListName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "PfoListNames", m_pfoListNames));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DLCheatHierarchyTool::Run	(	const PfoToMCParticleMap &	pfoToMCParticleMap,
		const ChildToParentPfoMap &	childToParentPfoMap,
		const HierarchyPfo &	parentPfo,
		const HierarchyPfo &	childPfo,
		bool &	isTrueLink,
		bool &	trueParentOrientation,
		bool &	trueChildOrientation
	)

Definition at line 35 of file DLCheatHierarchyTool.cc.

References lar_dl_content::HierarchyPfo::GetDownstreamPoint(), lar_dl_content::HierarchyPfo::GetPfo(), lar_dl_content::ExtremalPoint::GetPosition(), lar_dl_content::HierarchyPfo::GetUpstreamPoint(), and IsUpstreamTrueVertex().

Referenced by lar_dl_content::DLNeutrinoHierarchyAlgorithm::BuildPandoraHierarchy().

 {
     // If we dont know the Pfo->MCParticle match
     if ((pfoToMCParticleMap.find(parentPfo.GetPfo()) == pfoToMCParticleMap.end()) ||
         (pfoToMCParticleMap.find(childPfo.GetPfo()) == pfoToMCParticleMap.end()))
     {
         return STATUS_CODE_NOT_FOUND;
     }
 
     // If we dont know the true parentPfo
     if (childToParentPfoMap.find(childPfo.GetPfo()) == childToParentPfoMap.end())
         return STATUS_CODE_NOT_FOUND;
 
     isTrueLink = (childToParentPfoMap.at(childPfo.GetPfo()).first == parentPfo.GetPfo());
 
     // What is the true orientation of the parent?
     trueParentOrientation = this->IsUpstreamTrueVertex(
         pfoToMCParticleMap, parentPfo.GetPfo(), parentPfo.GetUpstreamPoint().GetPosition(), parentPfo.GetDownstreamPoint().GetPosition());
 
     // What is the true orientation of the child?
     trueChildOrientation = this->IsUpstreamTrueVertex(
         pfoToMCParticleMap, childPfo.GetPfo(), childPfo.GetUpstreamPoint().GetPosition(), childPfo.GetDownstreamPoint().GetPosition());
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DLCheatHierarchyTool::Run	(	const PfoToMCParticleMap &	pfoToMCParticleMap,
		const ChildToParentPfoMap &	childToParentPfoMap,
		const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const HierarchyPfo &	childPfo,
		bool &	isTrueLink,
		bool &	trueChildOrientation
	)

Definition at line 64 of file DLCheatHierarchyTool.cc.

References lar_dl_content::HierarchyPfo::GetDownstreamPoint(), lar_dl_content::HierarchyPfo::GetPfo(), lar_dl_content::ExtremalPoint::GetPosition(), lar_dl_content::HierarchyPfo::GetUpstreamPoint(), and IsUpstreamTrueVertex().

 {
     // If we dont know the Pfo->MCParticle match
     if (pfoToMCParticleMap.find(childPfo.GetPfo()) == pfoToMCParticleMap.end())
         return STATUS_CODE_NOT_FOUND;
 
     // If we dont know the true parentPfo
     if (childToParentPfoMap.find(childPfo.GetPfo()) == childToParentPfoMap.end())
         return STATUS_CODE_NOT_FOUND;
 
     isTrueLink = (childToParentPfoMap.at(childPfo.GetPfo()).first == pNeutrinoPfo);
 
     // What is the true orientation of the child?
     trueChildOrientation = this->IsUpstreamTrueVertex(
         pfoToMCParticleMap, childPfo.GetPfo(), childPfo.GetUpstreamPoint().GetPosition(), childPfo.GetDownstreamPoint().GetPosition());
 
     return STATUS_CODE_SUCCESS;
 }

float lar_dl_content::DLCheatHierarchyTool::SumEnergy ( const pandora::CaloHitList & caloHitList ) const

private

Sum the 'energy' of the W hits in an input CaloHitList.

Parameters

caloHitList the input CaloHitList

Returns: the summed energy

Definition at line 315 of file DLCheatHierarchyTool.cc.

References f.

Referenced by MatchPFParticles().

 {
     float totalEnergy(0.f);
 
     for (const CaloHit *const pCaloHit : caloHitList)
     {
         if (pCaloHit->GetHitType() == TPC_VIEW_W)
             totalEnergy += pCaloHit->GetElectromagneticEnergy();
     }
 
     return totalEnergy;
 }

Member Data Documentation

std::string lar_dl_content::DLCheatHierarchyTool::m_mcParticleListName

private

the MCParticle list name

Definition at line 205 of file DLCheatHierarchyTool.h.

Referenced by GetMCParticleList(), and ReadSettings().

std::string lar_dl_content::DLCheatHierarchyTool::m_neutrinoPfoListName

private

the neutrino pfo list name

Definition at line 206 of file DLCheatHierarchyTool.h.

Referenced by GetNeutrinoPfo(), and ReadSettings().

pandora::StringVector lar_dl_content::DLCheatHierarchyTool::m_pfoListNames

private

the vector of pfo list names

Definition at line 207 of file DLCheatHierarchyTool.h.

Referenced by MatchPFParticles(), and ReadSettings().

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

larpandoracontent/v04_15_01/source/larpandoradlcontent/LArCheating/DLCheatHierarchyTool.h
larpandoracontent/v04_15_01/source/larpandoradlcontent/LArCheating/DLCheatHierarchyTool.cc

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation