DeltaRayMatchingAlgorithm class. More...

#include <DeltaRayMatchingAlgorithm.h>

Inheritance diagram for lar_content::DeltaRayMatchingAlgorithm:

Classes
class	Particle
	Particle class. More...

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

Private Types
typedef std::vector< Particle >	ParticleList

typedef KDTreeLinkerAlgo < const pandora::CaloHit *, 2 >	HitKDTree2D

typedef KDTreeNodeInfoT< const pandora::CaloHit *, 2 >	HitKDNode2D

typedef std::vector< HitKDNode2D >	HitKDNode2DList

typedef std::unordered_map < const pandora::Cluster *, pandora::ClusterList >	ClusterToClustersMap

typedef std::unordered_map < const pandora::CaloHit , const pandora::Cluster >	HitToClusterMap

typedef std::unordered_map < const pandora::Cluster *, float >	ClusterLengthMap

typedef std::unordered_map < const pandora::ParticleFlowObject *, float >	PfoLengthMap

Private Member Functions
pandora::StatusCode	Run ()

void	InitializeNearbyClusterMaps ()
	Initialize nearby cluster maps. More...

void	InitializeNearbyClusterMap (const std::string &clusterListName, ClusterToClustersMap &nearbyClusters)
	Initialize a nearby cluster map with details relating to a specific cluster list. More...

void	ClearNearbyClusterMaps ()
	Clear nearby cluster maps. More...

void	GetAllPfos (const std::string &inputPfoListName, pandora::PfoVector &pfoVector) const
	Get a vector of all Pfos in the provided input Pfo lists. More...

void	GetTrackPfos (const std::string &inputPfoListName, pandora::PfoVector &pfoVector) const
	Get a vector of track-like Pfos in the provided input Pfo lists. More...

void	GetClusters (const std::string &clusterListName, pandora::ClusterVector &clusterVector) const
	Get a vector containing all available input clusters in the provided cluster list, storing sliding linear fits in the algorithm cache. More...

void	ThreeViewMatching (ClusterLengthMap &clusterLengthMap) const
	Match clusters using all three views. More...

void	TwoViewMatching (ClusterLengthMap &clusterLengthMap) const
	Match clusters using pairs of views. More...

void	OneViewMatching (ClusterLengthMap &clusterLengthMap) const
	Match clusters using single views. More...

void	ThreeViewMatching (const pandora::ClusterVector &clusters1, const pandora::ClusterVector &clusters2, const pandora::ClusterVector &clusters3, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, ParticleList &particleList) const
	Match clusters using all three views. More...

void	TwoViewMatching (const pandora::ClusterVector &clusters1, const pandora::ClusterVector &clusters2, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, ParticleList &particleList) const
	Match clusters using a pair of views. More...

void	OneViewMatching (const pandora::ClusterVector &clusters, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, ParticleList &particleList) const
	Match clusters using a single view. More...

void	SelectParticles (const ParticleList &inputParticles, ClusterLengthMap &clusterLengthMap, ParticleList &outputParticles) const
	Resolve any ambiguities between candidate particles. More...

void	CreateParticles (const ParticleList &particleList) const
	Build new particle flow objects. More...

void	FindBestParentPfo (const pandora::Cluster const pClusterU, const pandora::Cluster const pClusterV, const pandora::Cluster const pClusterW, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, const pandora::ParticleFlowObject &pBestPfo) const
	Find best Pfo to associate a UVW triplet. More...

float	GetLengthFromCache (const pandora::Cluster *const pCluster, ClusterLengthMap &clusterLengthMap) const
	Reduce number of length (squared) calculations by caching results when they are first obtained. More...

float	GetLengthFromCache (const pandora::ParticleFlowObject *const pPfo, PfoLengthMap &pfoLengthMap) const
	Reduce number of length (squared) calculations by caching results when they are first obtained. More...

float	GetLength (const Particle &particle, ClusterLengthMap &clusterLengthMap) const
	Get the length (squared) of a candidate particle. More...

bool	AreClustersMatched (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, const pandora::Cluster *const pCluster3) const
	Look at consistency of a combination of clusters. More...

float	GetDistanceSquaredToPfo (const pandora::Cluster const pCluster, const pandora::ParticleFlowObject const pPfo) const
	Get displacementr between cluster and particle flow object. More...

void	CreateDaughterPfo (const pandora::ClusterList &clusterList, const pandora::ParticleFlowObject *const pParentPfo) const
	Create a new Pfo from an input cluster list and set up a parent/daughter relationship. More...

void	AddToDaughterPfo (const pandora::ClusterList &clusterList, const pandora::ParticleFlowObject *const pParentPfo) const
	Merge an input cluster list with an existing daughter Pfo. More...

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

Private Attributes
std::string	m_parentPfoListName
	The parent pfo list name. More...

std::string	m_daughterPfoListName
	The daughter pfo list name for new daughter particles. More...

std::string	m_inputClusterListNameU
	The input cluster list name for the u view. More...

std::string	m_inputClusterListNameV
	The input cluster list name for the v view. More...

std::string	m_inputClusterListNameW
	The input cluster list name for the w view. More...

unsigned int	m_minCaloHitsPerCluster
	The min number of calo hits per candidate cluster. More...

float	m_xOverlapWindow
	The maximum allowed displacement in x position. More...

float	m_distanceForMatching
	The maximum allowed distance between tracks and delta rays. More...

float	m_pseudoChi2Cut
	Pseudo chi2 cut for three view matching. More...

float	m_searchRegion1D
	Search region, applied to each dimension, for look-up from kd-trees. More...

ClusterToClustersMap	m_nearbyClustersU
	The nearby clusters map for the u view. More...

ClusterToClustersMap	m_nearbyClustersV
	The nearby clusters map for the v view. More...

ClusterToClustersMap	m_nearbyClustersW
	The nearby clusters map for the w view. More...

Detailed Description

DeltaRayMatchingAlgorithm class.

Definition at line 28 of file DeltaRayMatchingAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, float> lar_content::DeltaRayMatchingAlgorithm::ClusterLengthMap

private

Definition at line 145 of file DeltaRayMatchingAlgorithm.h.

typedef std::unordered_map<const pandora::Cluster *, pandora::ClusterList> lar_content::DeltaRayMatchingAlgorithm::ClusterToClustersMap

private

Definition at line 99 of file DeltaRayMatchingAlgorithm.h.

typedef KDTreeNodeInfoT<const pandora::CaloHit *, 2> lar_content::DeltaRayMatchingAlgorithm::HitKDNode2D

private

Definition at line 96 of file DeltaRayMatchingAlgorithm.h.

typedef std::vector<HitKDNode2D> lar_content::DeltaRayMatchingAlgorithm::HitKDNode2DList

private

Definition at line 97 of file DeltaRayMatchingAlgorithm.h.

typedef KDTreeLinkerAlgo<const pandora::CaloHit *, 2> lar_content::DeltaRayMatchingAlgorithm::HitKDTree2D

private

Definition at line 95 of file DeltaRayMatchingAlgorithm.h.

typedef std::unordered_map<const pandora::CaloHit *, const pandora::Cluster *> lar_content::DeltaRayMatchingAlgorithm::HitToClusterMap

private

Definition at line 100 of file DeltaRayMatchingAlgorithm.h.

typedef std::vector<Particle> lar_content::DeltaRayMatchingAlgorithm::ParticleList

private

Definition at line 93 of file DeltaRayMatchingAlgorithm.h.

typedef std::unordered_map<const pandora::ParticleFlowObject *, float> lar_content::DeltaRayMatchingAlgorithm::PfoLengthMap

private

Definition at line 146 of file DeltaRayMatchingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::DeltaRayMatchingAlgorithm::DeltaRayMatchingAlgorithm ( )

Default constructor.

Definition at line 24 of file DeltaRayMatchingAlgorithm.cc.

                                                      :
     m_minCaloHitsPerCluster(3),
     m_xOverlapWindow(1.f),
     m_distanceForMatching(5.f),
     m_pseudoChi2Cut(3.f),
     m_searchRegion1D(5.f)
 {
 }

Member Function Documentation

void lar_content::DeltaRayMatchingAlgorithm::AddToDaughterPfo	(	const pandora::ClusterList &	clusterList,
		const pandora::ParticleFlowObject *const	pParentPfo
	)		const

private

Merge an input cluster list with an existing daughter Pfo.

Parameters

clusterList	the list of clusters
pParentPfo	address of the parent pfo

Definition at line 696 of file DeltaRayMatchingAlgorithm.cc.

 {
     for (const Cluster *const pDaughterCluster : clusterList)
     {
         const HitType hitType(LArClusterHelper::GetClusterHitType(pDaughterCluster));
         const std::string clusterListName(
             (TPC_VIEW_U == hitType) ? m_inputClusterListNameU : (TPC_VIEW_V == hitType) ? m_inputClusterListNameV : m_inputClusterListNameW);
 
         ClusterList pfoClusters;
         LArPfoHelper::GetClusters(pParentPfo, hitType, pfoClusters);
 
         if (pfoClusters.empty())
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         const Cluster *const pParentCluster = *(pfoClusters.begin());
 
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
             PandoraContentApi::MergeAndDeleteClusters(*this, pParentCluster, pDaughterCluster, clusterListName, clusterListName));
     }
 }

bool lar_content::DeltaRayMatchingAlgorithm::AreClustersMatched	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		const pandora::Cluster *const	pCluster3
	)		const

private

Look at consistency of a combination of clusters.

Parameters

pCluster1	pointer to first luster
pCluster2	pointer to second cluster
pCluster3	pointer to third cluster

Definition at line 436 of file DeltaRayMatchingAlgorithm.cc.

 {
     if (nullptr == pCluster1 && nullptr == pCluster2 && nullptr == pCluster3)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     // First step: Check X overlap
     float xMin1(-std::numeric_limits<float>::max()), xMax1(+std::numeric_limits<float>::max());
     float xMin2(-std::numeric_limits<float>::max()), xMax2(+std::numeric_limits<float>::max());
     float xMin3(-std::numeric_limits<float>::max()), xMax3(+std::numeric_limits<float>::max());
 
     if (nullptr != pCluster1)
         pCluster1->GetClusterSpanX(xMin1, xMax1);
 
     if (nullptr != pCluster2)
         pCluster2->GetClusterSpanX(xMin2, xMax2);
 
     if (nullptr != pCluster3)
         pCluster3->GetClusterSpanX(xMin3, xMax3);
 
     const float xPitch(0.5 * m_xOverlapWindow);
     const float xMin(std::max(xMin1, std::max(xMin2, xMin3)) - xPitch);
     const float xMax(std::min(xMax1, std::min(xMax2, xMax3)) + xPitch);
     const float xOverlap(xMax - xMin);
 
     if (xOverlap < std::numeric_limits<float>::epsilon())
         return false;
 
     if (nullptr == pCluster1 || nullptr == pCluster2 || nullptr == pCluster3)
         return true;
 
     // Second step: Check 3D matching
     const HitType hitType1(LArClusterHelper::GetClusterHitType(pCluster1));
     const HitType hitType2(LArClusterHelper::GetClusterHitType(pCluster2));
     const HitType hitType3(LArClusterHelper::GetClusterHitType(pCluster3));
 
     if (hitType1 == hitType2 || hitType2 == hitType3 || hitType3 == hitType1)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     const unsigned int nSamplingPoints(1 + static_cast<unsigned int>(xOverlap / xPitch));
 
     for (unsigned int n = 0; n < nSamplingPoints; ++n)
     {
         const float x(xMin + (xMax - xMin) * (static_cast<float>(n) + 0.5f) / static_cast<float>(nSamplingPoints));
         const float xmin(x - xPitch);
         const float xmax(x + xPitch);
 
         try
         {
             float zMin1(0.f), zMin2(0.f), zMin3(0.f), zMax1(0.f), zMax2(0.f), zMax3(0.f);
             pCluster1->GetClusterSpanZ(xmin, xmax, zMin1, zMax1);
             pCluster2->GetClusterSpanZ(xmin, xmax, zMin2, zMax2);
             pCluster3->GetClusterSpanZ(xmin, xmax, zMin3, zMax3);
 
             const float z1(0.5f * (zMin1 + zMax1));
             const float z2(0.5f * (zMin2 + zMax2));
             const float z3(0.5f * (zMin3 + zMax3));
 
             const float dz1(zMax1 - zMin1);
             const float dz2(zMax2 - zMin2);
             const float dz3(zMax3 - zMin3);
             const float dz4(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
 
             const float zproj1(LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType2, hitType3, z2, z3));
             const float zproj2(LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType3, hitType1, z3, z1));
             const float zproj3(LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType1, hitType2, z1, z2));
 
             const float deltaSquared(((z1 - zproj1) * (z1 - zproj1) + (z2 - zproj2) * (z2 - zproj2) + (z3 - zproj3) * (z3 - zproj3)) / 3.f);
             const float sigmaSquared(dz1 * dz1 + dz2 * dz2 + dz3 * dz3 + dz4 * dz4);
             const float pseudoChi2(deltaSquared / sigmaSquared);
 
             if (pseudoChi2 < m_pseudoChi2Cut)
                 return true;
         }
         catch (StatusCodeException &statusCodeException)
         {
             if (STATUS_CODE_NOT_FOUND != statusCodeException.GetStatusCode())
                 throw statusCodeException;
         }
     }
 
     return false;
 }

void lar_content::DeltaRayMatchingAlgorithm::ClearNearbyClusterMaps ( )

private

Clear nearby cluster maps.

Definition at line 125 of file DeltaRayMatchingAlgorithm.cc.

 {
     m_nearbyClustersU.clear();
     m_nearbyClustersV.clear();
     m_nearbyClustersW.clear();
 }

void lar_content::DeltaRayMatchingAlgorithm::CreateDaughterPfo	(	const pandora::ClusterList &	clusterList,
		const pandora::ParticleFlowObject *const	pParentPfo
	)		const

private

Create a new Pfo from an input cluster list and set up a parent/daughter relationship.

Parameters

clusterList	the list of clusters
pParentPfo	address of the parent pfo

Definition at line 669 of file DeltaRayMatchingAlgorithm.cc.

 {
     const PfoList *pPfoList = NULL;
     std::string pfoListName;
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pPfoList, pfoListName));
 
     // TODO Correct these placeholder parameters
     PandoraContentApi::ParticleFlowObject::Parameters pfoParameters;
     pfoParameters.m_particleId = E_MINUS; // SHOWER
     pfoParameters.m_charge = PdgTable::GetParticleCharge(pfoParameters.m_particleId.Get());
     pfoParameters.m_mass = PdgTable::GetParticleMass(pfoParameters.m_particleId.Get());
     pfoParameters.m_energy = 0.f;
     pfoParameters.m_momentum = CartesianVector(0.f, 0.f, 0.f);
     pfoParameters.m_clusterList = clusterList;
 
     const ParticleFlowObject *pDaughterPfo(NULL);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::Create(*this, pfoParameters, pDaughterPfo));
 
     if (!pPfoList->empty())
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Pfo>(*this, m_daughterPfoListName));
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*this, pParentPfo, pDaughterPfo));
     }
 }

void lar_content::DeltaRayMatchingAlgorithm::CreateParticles ( const ParticleList & particleList ) const

private

Build new particle flow objects.

Parameters

particleList the list of candidate particles

Definition at line 385 of file DeltaRayMatchingAlgorithm.cc.

 {
     PfoVector parentVector, daughterVector;
     this->GetTrackPfos(m_parentPfoListName, parentVector);
     this->GetAllPfos(m_daughterPfoListName, daughterVector);
 
     PfoList parentList(parentVector.begin(), parentVector.end());
     PfoList daughterList(daughterVector.begin(), daughterVector.end());
 
     for (const Particle &particle : particleList)
     {
         const ParticleFlowObject *const pParentPfo = particle.GetParentPfo();
 
         if (NULL == pParentPfo)
             continue;
 
         const Cluster *const pClusterU = particle.GetClusterU();
         const Cluster *const pClusterV = particle.GetClusterV();
         const Cluster *const pClusterW = particle.GetClusterW();
 
         if (NULL == pClusterU && NULL == pClusterV && NULL == pClusterW)
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         ClusterList clusterList;
 
         if (pClusterU)
             clusterList.push_back(pClusterU);
 
         if (pClusterV)
             clusterList.push_back(pClusterV);
 
         if (pClusterW)
             clusterList.push_back(pClusterW);
 
         if (parentList.end() != std::find(parentList.begin(), parentList.end(), pParentPfo))
         {
             this->CreateDaughterPfo(clusterList, pParentPfo);
         }
         else if (daughterList.end() != std::find(daughterList.begin(), daughterList.end(), pParentPfo))
         {
             this->AddToDaughterPfo(clusterList, pParentPfo);
         }
         else
         {
             throw StatusCodeException(STATUS_CODE_FAILURE);
         }
     }
 }

void lar_content::DeltaRayMatchingAlgorithm::FindBestParentPfo	(	const pandora::Cluster *const	pClusterU,
		const pandora::Cluster *const	pClusterV,
		const pandora::Cluster *const	pClusterW,
		ClusterLengthMap &	clusterLengthMap,
		PfoLengthMap &	pfoLengthMap,
		const pandora::ParticleFlowObject *&	pBestPfo
	)		const

private

Find best Pfo to associate a UVW triplet.

Parameters

pClusterU	pointer to U view cluster
pClusterV	pointer to V view cluster
pClusterW	pointer to W view cluster
clusterLengthMap	the cluster length map
pfoLengthMap	the pfo length map
pBestPfo	to receive the address of the best Pfo

Definition at line 521 of file DeltaRayMatchingAlgorithm.cc.

 {
     PfoVector pfoVector;
     this->GetTrackPfos(m_parentPfoListName, pfoVector);
     this->GetAllPfos(m_daughterPfoListName, pfoVector);
 
     if (pfoVector.empty())
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     unsigned int numViews(0);
     float lengthSquared(0.f);
 
     if (pCluster1)
     {
         lengthSquared += this->GetLengthFromCache(pCluster1, clusterLengthMap);
         ++numViews;
     }
 
     if (pCluster2)
     {
         lengthSquared += this->GetLengthFromCache(pCluster2, clusterLengthMap);
         ++numViews;
     }
 
     if (pCluster3)
     {
         lengthSquared += this->GetLengthFromCache(pCluster3, clusterLengthMap);
         ++numViews;
     }
 
     float bestDistanceSquared(static_cast<float>(numViews) * m_distanceForMatching * m_distanceForMatching);
 
     for (const ParticleFlowObject *const pPfo : pfoVector)
     {
         if (lengthSquared > this->GetLengthFromCache(pPfo, pfoLengthMap))
             continue;
 
         try
         {
             float distanceSquared(0.f);
 
             if (NULL != pCluster1)
                 distanceSquared += this->GetDistanceSquaredToPfo(pCluster1, pPfo);
 
             if (NULL != pCluster2)
                 distanceSquared += this->GetDistanceSquaredToPfo(pCluster2, pPfo);
 
             if (NULL != pCluster3)
                 distanceSquared += this->GetDistanceSquaredToPfo(pCluster3, pPfo);
 
             if (distanceSquared < bestDistanceSquared)
             {
                 pBestPfo = pPfo;
                 bestDistanceSquared = distanceSquared;
             }
         }
         catch (StatusCodeException &statusCodeException)
         {
             if (!(STATUS_CODE_NOT_FOUND == statusCodeException.GetStatusCode()))
                 throw statusCodeException;
         }
     }
 }

void lar_content::DeltaRayMatchingAlgorithm::GetAllPfos	(	const std::string &	inputPfoListName,
		pandora::PfoVector &	pfoVector
	)		const

private

Get a vector of all Pfos in the provided input Pfo lists.

Parameters

inputPfoListName	the input Pfo list name
pfoVector	the output vector of Pfos

Definition at line 134 of file DeltaRayMatchingAlgorithm.cc.

 {
     const PfoList *pPfoList = NULL;
     PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, inputPfoListName, pPfoList));
 
     if (NULL == pPfoList)
         return;
 
     for (PfoList::const_iterator iter = pPfoList->begin(), iterEnd = pPfoList->end(); iter != iterEnd; ++iter)
         pfoVector.push_back(*iter);
 
     std::sort(pfoVector.begin(), pfoVector.end(), LArPfoHelper::SortByNHits);
 }

void lar_content::DeltaRayMatchingAlgorithm::GetClusters	(	const std::string &	clusterListName,
		pandora::ClusterVector &	clusterVector
	)		const

private

Get a vector containing all available input clusters in the provided cluster list, storing sliding linear fits in the algorithm cache.

Parameters

clusterListName	the vector of cluster list names
clusterVector	to receive the populated cluster vector

Definition at line 170 of file DeltaRayMatchingAlgorithm.cc.

 {
     const ClusterList *pClusterList = NULL;
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, inputClusterListName, pClusterList))
 
     if (NULL == pClusterList)
         return;
 
     for (ClusterList::const_iterator cIter = pClusterList->begin(), cIterEnd = pClusterList->end(); cIter != cIterEnd; ++cIter)
     {
         const Cluster *const pCluster = *cIter;
 
         if (!pCluster->IsAvailable() || (pCluster->GetNCaloHits() < m_minCaloHitsPerCluster))
             continue;
 
         clusterVector.push_back(pCluster);
     }
 
     std::sort(clusterVector.begin(), clusterVector.end(), LArClusterHelper::SortByNHits);
 }

float lar_content::DeltaRayMatchingAlgorithm::GetDistanceSquaredToPfo	(	const pandora::Cluster *const	pCluster,
		const pandora::ParticleFlowObject *const	pPfo
	)		const

private

Get displacementr between cluster and particle flow object.

Parameters

pCluster	pointer to cluster
pPfo	pointer to particle flow object

Definition at line 634 of file DeltaRayMatchingAlgorithm.cc.

 {
     const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
 
     if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     ClusterList comparisonList;
     const ClusterToClustersMap &nearbyClusters((TPC_VIEW_U == hitType) ? m_nearbyClustersU : (TPC_VIEW_V == hitType) ? m_nearbyClustersV : m_nearbyClustersW);
 
     if (!nearbyClusters.count(pCluster))
         return std::numeric_limits<float>::max();
 
     ClusterList pfoClusterList;
     LArPfoHelper::GetClusters(pPfo, hitType, pfoClusterList);
 
     for (const Cluster *const pPfoCluster : pfoClusterList)
     {
         const ClusterList &clusterList(nearbyClusters.at(pCluster));
 
         if ((clusterList.end() != std::find(clusterList.begin(), clusterList.end(), pPfoCluster)) &&
             (comparisonList.end() == std::find(comparisonList.begin(), comparisonList.end(), pPfoCluster)))
         {
             comparisonList.push_back(pPfoCluster);
         }
     }
 
     if (comparisonList.empty())
         return std::numeric_limits<float>::max();
 
     return LArClusterHelper::GetClosestDistance(pCluster, comparisonList);
 }

float lar_content::DeltaRayMatchingAlgorithm::GetLength	(	const Particle &	particle,
		ClusterLengthMap &	clusterLengthMap
	)		const

private

Get the length (squared) of a candidate particle.

Parameters

particle	the particle
clusterLengthMap	the cluster length map

Returns: the length (squared)

Definition at line 616 of file DeltaRayMatchingAlgorithm.cc.

 {
     float lengthSquared(0.f);
 
     if (particle.GetClusterU())
         lengthSquared += this->GetLengthFromCache(particle.GetClusterU(), clusterLengthMap);
 
     if (particle.GetClusterV())
         lengthSquared += this->GetLengthFromCache(particle.GetClusterV(), clusterLengthMap);
 
     if (particle.GetClusterW())
         lengthSquared += this->GetLengthFromCache(particle.GetClusterW(), clusterLengthMap);
 
     return lengthSquared;
 }

float lar_content::DeltaRayMatchingAlgorithm::GetLengthFromCache	(	const pandora::Cluster *const	pCluster,
		ClusterLengthMap &	clusterLengthMap
	)		const

private

Reduce number of length (squared) calculations by caching results when they are first obtained.

Parameters

pCluster	the cluster
clusterLengthMap	the cluster length map

Returns: the length (squared)

float lar_content::DeltaRayMatchingAlgorithm::GetLengthFromCache	(	const pandora::ParticleFlowObject *const	pPfo,
		PfoLengthMap &	pfoLengthMap
	)		const

private

Reduce number of length (squared) calculations by caching results when they are first obtained.

Parameters

pPfo	the pfo
pfoLengthMap	the pfo length map

Returns: the length (squared)

Definition at line 602 of file DeltaRayMatchingAlgorithm.cc.

 {
     PfoLengthMap::const_iterator iter = pfoLengthMap.find(pPfo);
 
     if (pfoLengthMap.end() != iter)
         return iter->second;
 
     const float lengthSquared(LArPfoHelper::GetTwoDLengthSquared(pPfo));
     (void)pfoLengthMap.insert(PfoLengthMap::value_type(pPfo, lengthSquared));
     return lengthSquared;
 }

void lar_content::DeltaRayMatchingAlgorithm::GetTrackPfos	(	const std::string &	inputPfoListName,
		pandora::PfoVector &	pfoVector
	)		const

private

Get a vector of track-like Pfos in the provided input Pfo lists.

Parameters

inputPfoListName	the input Pfo list name
pfoVector	the output vector of Pfos

Definition at line 150 of file DeltaRayMatchingAlgorithm.cc.

 {
     PfoVector inputVector;
     this->GetAllPfos(inputPfoListName, inputVector);
 
     for (PfoVector::const_iterator iter = inputVector.begin(), iterEnd = inputVector.end(); iter != iterEnd; ++iter)
     {
         const ParticleFlowObject *const pPfo = *iter;
 
         if (!LArPfoHelper::IsTrack(pPfo))
             continue;
 
         pfoVector.push_back(pPfo);
     }
 
     // ATTN Track pfo list is sorted only because the inputVector is sorted
 }

void lar_content::DeltaRayMatchingAlgorithm::InitializeNearbyClusterMap	(	const std::string &	clusterListName,
		ClusterToClustersMap &	nearbyClusters
	)

private

Initialize a nearby cluster map with details relating to a specific cluster list.

Parameters

clusterListName	the cluster list name
nearbyClustersMap	to receive the nearby clusters map

Definition at line 72 of file DeltaRayMatchingAlgorithm.cc.

 {
     const ClusterList *pClusterList = NULL;
     PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, clusterListName, pClusterList))
 
     if ((NULL == pClusterList) || pClusterList->empty())
         return;
 
     HitToClusterMap hitToClusterMap;
     CaloHitList allCaloHits;
 
     for (const Cluster *const pCluster : *pClusterList)
     {
         CaloHitList daughterHits;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(daughterHits);
         allCaloHits.insert(allCaloHits.end(), daughterHits.begin(), daughterHits.end());
 
         for (const CaloHit *const pCaloHit : daughterHits)
             (void)hitToClusterMap.insert(HitToClusterMap::value_type(pCaloHit, pCluster));
     }
 
     HitKDTree2D kdTree;
     HitKDNode2DList hitKDNode2DList;
 
     KDTreeBox hitsBoundingRegion2D(fill_and_bound_2d_kd_tree(allCaloHits, hitKDNode2DList));
     kdTree.build(hitKDNode2DList, hitsBoundingRegion2D);
 
     for (const Cluster *const pCluster : *pClusterList)
     {
         CaloHitList daughterHits;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(daughterHits);
 
         for (const CaloHit *const pCaloHit : daughterHits)
         {
             KDTreeBox searchRegionHits = build_2d_kd_search_region(pCaloHit, m_searchRegion1D, m_searchRegion1D);
 
             HitKDNode2DList found;
             kdTree.search(searchRegionHits, found);
 
             for (const auto &hit : found)
             {
                 ClusterList &nearbyClusterList(nearbyClusters[pCluster]);
                 const Cluster *const pNearbyCluster(hitToClusterMap.at(hit.data));
 
                 if (nearbyClusterList.end() == std::find(nearbyClusterList.begin(), nearbyClusterList.end(), pNearbyCluster))
                     nearbyClusterList.push_back(pNearbyCluster);
             }
         }
     }
 }

void lar_content::DeltaRayMatchingAlgorithm::InitializeNearbyClusterMaps ( )

private

Initialize nearby cluster maps.

Definition at line 62 of file DeltaRayMatchingAlgorithm.cc.

 {
     this->ClearNearbyClusterMaps();
     this->InitializeNearbyClusterMap(m_inputClusterListNameU, m_nearbyClustersU);
     this->InitializeNearbyClusterMap(m_inputClusterListNameV, m_nearbyClustersV);
     this->InitializeNearbyClusterMap(m_inputClusterListNameW, m_nearbyClustersW);
 }

void lar_content::DeltaRayMatchingAlgorithm::OneViewMatching ( ClusterLengthMap & clusterLengthMap ) const

private

Match clusters using single views.

Parameters

clusterLengthMap the cluster length map

Definition at line 228 of file DeltaRayMatchingAlgorithm.cc.

 {
     ClusterVector clustersU, clustersV, clustersW;
     this->GetClusters(m_inputClusterListNameU, clustersU);
     this->GetClusters(m_inputClusterListNameV, clustersV);
     this->GetClusters(m_inputClusterListNameW, clustersW);
 
     PfoLengthMap pfoLengthMap;
     ParticleList initialParticleList, finalParticleList;
     this->ThreeViewMatching(clustersU, clustersV, clustersW, clusterLengthMap, pfoLengthMap, initialParticleList);
     this->OneViewMatching(clustersU, clusterLengthMap, pfoLengthMap, initialParticleList);
     this->OneViewMatching(clustersV, clusterLengthMap, pfoLengthMap, initialParticleList);
     this->OneViewMatching(clustersW, clusterLengthMap, pfoLengthMap, initialParticleList);
     this->SelectParticles(initialParticleList, clusterLengthMap, finalParticleList);
     this->CreateParticles(finalParticleList);
 }

void lar_content::DeltaRayMatchingAlgorithm::OneViewMatching	(	const pandora::ClusterVector &	clusters,
		ClusterLengthMap &	clusterLengthMap,
		PfoLengthMap &	pfoLengthMap,
		ParticleList &	particleList
	)		const

private

Match clusters using a single view.

Parameters

clusters	the list of clusters in the provided view
clusterLengthMap	the cluster length map
pfoLengthMap	the pfo length map
particleList	the output list of particles

StatusCode lar_content::DeltaRayMatchingAlgorithm::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Definition at line 779 of file DeltaRayMatchingAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "ParentPfoListName", m_parentPfoListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "DaughterPfoListName", m_daughterPfoListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputClusterListNameU", m_inputClusterListNameU));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputClusterListNameV", m_inputClusterListNameV));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputClusterListNameW", m_inputClusterListNameW));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCaloHitsPerCluster", m_minCaloHitsPerCluster));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "OverlapWindow", m_xOverlapWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DistanceForMatching", m_distanceForMatching));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PseudoChi2Cut", m_pseudoChi2Cut));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SearchRegion1D", m_searchRegion1D));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::DeltaRayMatchingAlgorithm::Run ( )

private

Definition at line 35 of file DeltaRayMatchingAlgorithm.cc.

 {
     PfoVector pfoVector;
     this->GetAllPfos(m_parentPfoListName, pfoVector);
 
     if (pfoVector.empty())
     {
         if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
             std::cout << "DeltaRayMatchingAlgorithm: pfo list " << m_parentPfoListName << " unavailable." << std::endl;
 
         return STATUS_CODE_SUCCESS;
     }
 
     this->InitializeNearbyClusterMaps();
 
     ClusterLengthMap clusterLengthMap;
     this->ThreeViewMatching(clusterLengthMap);
     this->TwoViewMatching(clusterLengthMap);
     this->OneViewMatching(clusterLengthMap);
 
     this->ClearNearbyClusterMaps();
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::DeltaRayMatchingAlgorithm::SelectParticles	(	const ParticleList &	inputParticles,
		ClusterLengthMap &	clusterLengthMap,
		ParticleList &	outputParticles
	)		const

private

Resolve any ambiguities between candidate particles.

Parameters

inputParticles	the input list of candidate particles
clusterLengthMap	the cluster length map
outputParticles	the output list of candidate particles

Definition at line 338 of file DeltaRayMatchingAlgorithm.cc.

 {
     for (const Particle &particle1 : initialParticles)
     {
         bool isGoodParticle(true);
 
         for (const Particle &particle2 : initialParticles)
         {
             const bool commonU(particle1.GetClusterU() == particle2.GetClusterU());
             const bool commonV(particle1.GetClusterV() == particle2.GetClusterV());
             const bool commonW(particle1.GetClusterW() == particle2.GetClusterW());
 
             const bool ambiguousU(commonU && NULL != particle1.GetClusterU());
             const bool ambiguousV(commonV && NULL != particle1.GetClusterV());
             const bool ambiguousW(commonW && NULL != particle1.GetClusterW());
 
             if (commonU && commonV && commonW)
                 continue;
 
             if (ambiguousU || ambiguousV || ambiguousW)
             {
                 if (particle2.GetNViews() > particle1.GetNViews())
                 {
                     isGoodParticle = false;
                 }
                 else if (particle2.GetNViews() == particle1.GetNViews() && NULL != particle2.GetParentPfo())
                 {
                     if ((NULL == particle1.GetParentPfo()) || (particle2.GetNCaloHits() > particle1.GetNCaloHits()) ||
                         (particle2.GetNCaloHits() == particle1.GetNCaloHits() &&
                             this->GetLength(particle2, clusterLengthMap) >= this->GetLength(particle1, clusterLengthMap)))
                     {
                         isGoodParticle = false;
                     }
                 }
 
                 if (!isGoodParticle)
                     break;
             }
         }
 
         if (isGoodParticle && NULL != particle1.GetParentPfo())
             finalParticles.push_back(particle1);
     }
 }

void lar_content::DeltaRayMatchingAlgorithm::ThreeViewMatching ( ClusterLengthMap & clusterLengthMap ) const

private

Match clusters using all three views.

Parameters

clusterLengthMap the cluster length map

Definition at line 194 of file DeltaRayMatchingAlgorithm.cc.

 {
     ClusterVector clustersU, clustersV, clustersW;
     this->GetClusters(m_inputClusterListNameU, clustersU);
     this->GetClusters(m_inputClusterListNameV, clustersV);
     this->GetClusters(m_inputClusterListNameW, clustersW);
 
     PfoLengthMap pfoLengthMap;
     ParticleList initialParticleList, finalParticleList;
     this->ThreeViewMatching(clustersU, clustersV, clustersW, clusterLengthMap, pfoLengthMap, initialParticleList);
     this->SelectParticles(initialParticleList, clusterLengthMap, finalParticleList);
     this->CreateParticles(finalParticleList);
 }

void lar_content::DeltaRayMatchingAlgorithm::ThreeViewMatching	(	const pandora::ClusterVector &	clusters1,
		const pandora::ClusterVector &	clusters2,
		const pandora::ClusterVector &	clusters3,
		ClusterLengthMap &	clusterLengthMap,
		PfoLengthMap &	pfoLengthMap,
		ParticleList &	particleList
	)		const

private

Match clusters using all three views.

Parameters

clusters1	the list of clusters in the first view
clusters2	the list of clusters in the second view
clusters3	the list of clusters in the third view
clusterLengthMap	the cluster length map
pfoLengthMap	the pfo length map
particleList	the output list of particles

void lar_content::DeltaRayMatchingAlgorithm::TwoViewMatching ( ClusterLengthMap & clusterLengthMap ) const

private

Match clusters using pairs of views.

Parameters

clusterLengthMap the cluster length map

Definition at line 210 of file DeltaRayMatchingAlgorithm.cc.

 {
     ClusterVector clustersU, clustersV, clustersW;
     this->GetClusters(m_inputClusterListNameU, clustersU);
     this->GetClusters(m_inputClusterListNameV, clustersV);
     this->GetClusters(m_inputClusterListNameW, clustersW);
 
     PfoLengthMap pfoLengthMap;
     ParticleList initialParticleList, finalParticleList;
     this->TwoViewMatching(clustersU, clustersV, clusterLengthMap, pfoLengthMap, initialParticleList);
     this->TwoViewMatching(clustersV, clustersW, clusterLengthMap, pfoLengthMap, initialParticleList);
     this->TwoViewMatching(clustersW, clustersU, clusterLengthMap, pfoLengthMap, initialParticleList);
     this->SelectParticles(initialParticleList, clusterLengthMap, finalParticleList);
     this->CreateParticles(finalParticleList);
 }

void lar_content::DeltaRayMatchingAlgorithm::TwoViewMatching	(	const pandora::ClusterVector &	clusters1,
		const pandora::ClusterVector &	clusters2,
		ClusterLengthMap &	clusterLengthMap,
		PfoLengthMap &	pfoLengthMap,
		ParticleList &	particleList
	)		const

private

Match clusters using a pair of views.

Parameters

clusters1	the list of clusters in the first view
clusters2	the list of clusters in the second view
clusterLengthMap	the cluster length map
pfoLengthMap	the pfo length map
particleList	the output list of particles