OneViewDeltaRayMatchingAlgorithm class. More...

#include <OneViewDeltaRayMatchingAlgorithm.h>

Inheritance diagram for lar_content::OneViewDeltaRayMatchingAlgorithm:

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

Private Member Functions
pandora::StatusCode	Run ()

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

const pandora::ClusterList	GetInputClusterList (const pandora::HitType hitType)
	Get the input cluster list of a given hit type. More...

const pandora::PfoList	GetMuonPfoList ()
	Get the input cosmic ray pfo list. More...

const pandora::PfoList	GetDeltaRayPfoList ()
	Get the input delta ray pfo list. More...

void	PerformOneViewMatching (const pandora::HitType hitType)
	Use nearby muon pfos to project into other views and attempt to match the remaining delta ray clusters. More...

bool	IsMuonPfo (const pandora::Cluster *const pCluster)
	Determine whether an input cluster belongs to a cosmic ray pfo. More...

bool	AddIntoExistingDeltaRay (const pandora::Cluster *const pAvailableCluster, const pandora::PfoVector &nearbyMuonPfoVector)
	Use nearby muon pfos to project into other views and attempt to add a remaining delta ray cluster into an existing delta ray pfo. More...

const pandora::Cluster *	GetBestProjectedCluster (const pandora::ClusterList &deltaRayClusterGroup, const pandora::ParticleFlowObject *const pNearbyMuonPfo, const pandora::HitType hitType, const bool findAvailable)
	Get the best matched available or unavailable cluster of a remaining delta ray cluster group wrt a cosmic ray pfo. More...

bool	IsDeltaRayPfo (const pandora::Cluster *const pCluster)
	Determine whether an input cluster belongs to a delta ray pfo. More...

void	GetClusterSpanX (const pandora::ClusterList &clusterList, float &spanMinX, float &spanMaxX)
	Determine cluster span (in x) of a group of clusters. More...

void	CreateDeltaRay (const pandora::Cluster *const pAvailableCluster, const pandora::PfoVector &nearbyMuonPfoVector, pandora::ClusterSet &modifiedClusters)
	Use nearby muon pfos to project into other views and attempt to match a remaining delta ray cluster to form a delta ray pfo. More...

void	GetNearbyAvailableClusters (const pandora::Cluster *const pCluster, pandora::ClusterList &consideredClusters, pandora::ClusterList &foundClusters)
	In the view of the input available cluster, gather nearby available clusters. More...

const pandora::Cluster *	MergeClusterGroup (const pandora::ClusterList &clusterGroup)
	Merge a collection of available clusters together updating hit containers accordingly. More...

void	CreatePfo (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, const pandora::Cluster *const pCluster3)
	Create a pfo from the input clusters updating the cluster to pfo map accordingly. More...

void	PerformRecovery (const pandora::HitType hitType)
	Create a delta ray pfo from any remaining, significant clusters. More...

Private Attributes
std::string	m_muonPfoListName
	The list of reconstructed cosmic ray pfos. More...

std::string	m_deltaRayPfoListName
	The list of reconstructed delta ray pfos. More...

std::string	m_inputClusterListNameU
	The list of reconstructed U clusters. More...

std::string	m_inputClusterListNameV
	The list of reconstructed V clusters. More...

std::string	m_inputClusterListNameW
	The list of reconstructed W clusters. More...

std::string	m_outputPfoListName
	The list to receive the created delta ray pfos. More...

DeltaRayMatchingContainers	m_deltaRayMatchingContainers
	The class of hit, cluster and pfo ownership and proximity maps. More...

float	m_overlapExtension
	The extension to each side of the x overlap region in which to search for matched clusters. More...

unsigned int	m_minClusterHits
	The minimum number of hits for a cluster to be significant. More...

Detailed Description

OneViewDeltaRayMatchingAlgorithm class.

Definition at line 23 of file OneViewDeltaRayMatchingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::OneViewDeltaRayMatchingAlgorithm::OneViewDeltaRayMatchingAlgorithm ( )

Default constructor.

Definition at line 23 of file OneViewDeltaRayMatchingAlgorithm.cc.

                                                                    : m_overlapExtension(1.f), m_minClusterHits(3)
 {
 }

Member Function Documentation

bool lar_content::OneViewDeltaRayMatchingAlgorithm::AddIntoExistingDeltaRay	(	const pandora::Cluster *const	pAvailableCluster,
		const pandora::PfoVector &	nearbyMuonPfoVector
	)

private

Use nearby muon pfos to project into other views and attempt to add a remaining delta ray cluster into an existing delta ray pfo.

Parameters

pAvailableCluster	the address of the delta ray cluster to add
nearbyMuonPfoVector	the vector of nearby cosmic ray pfos

Returns: whether the input cluster was aded into an existing delta ray pfo

Definition at line 191 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const HitType hitType(LArClusterHelper::GetClusterHitType(pAvailableCluster));
     const HitType projectedHitType1((hitType == TPC_VIEW_U) ? TPC_VIEW_V : (hitType == TPC_VIEW_V) ? TPC_VIEW_W : TPC_VIEW_U);
     const HitType projectedHitType2((projectedHitType1 == TPC_VIEW_U) ? TPC_VIEW_V : (projectedHitType1 == TPC_VIEW_V) ? TPC_VIEW_W : TPC_VIEW_U);
     const DeltaRayMatchingContainers::ClusterToPfoMap &clusterToPfoMap1(m_deltaRayMatchingContainers.GetClusterToPfoMap(projectedHitType1));
     const DeltaRayMatchingContainers::ClusterToPfoMap &clusterToPfoMap2(m_deltaRayMatchingContainers.GetClusterToPfoMap(projectedHitType2));
 
     for (const ParticleFlowObject *const pNearbyMuonPfo : nearbyMuonPfoVector)
     {
         const Cluster *const pProjectedCluster1(this->GetBestProjectedCluster({pAvailableCluster}, pNearbyMuonPfo, projectedHitType1, false));
         const Cluster *const pProjectedCluster2(this->GetBestProjectedCluster({pAvailableCluster}, pNearbyMuonPfo, projectedHitType2, false));
 
         if ((!pProjectedCluster1) || (!pProjectedCluster2))
             continue;
 
         const ParticleFlowObject *const pPfo1(clusterToPfoMap1.at(pProjectedCluster1));
         const ParticleFlowObject *const pPfo2(clusterToPfoMap2.at(pProjectedCluster2));
 
         if (pPfo1 == pPfo2)
         {
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToPfo(*this, pPfo1, pAvailableCluster));
 
             m_deltaRayMatchingContainers.AddClustersToPfoMaps(pPfo1);
 
             return true;
         }
     }
 
     return false;
 }

void lar_content::OneViewDeltaRayMatchingAlgorithm::CreateDeltaRay	(	const pandora::Cluster *const	pAvailableCluster,
		const pandora::PfoVector &	nearbyMuonPfoVector,
		pandora::ClusterSet &	modifiedClusters
	)

private

Use nearby muon pfos to project into other views and attempt to match a remaining delta ray cluster to form a delta ray pfo.

Parameters

pAvailableCluster	the address of the delta ray cluster to add
nearbyMuonPfoVector	the vector of nearby cosmic ray pfos
modifiedClusters	the output list of any delta ray clusters in the view of pAvailableCluster made unavailable in this process

Definition at line 310 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     ClusterList clusterGroup, consideredClusters;
     this->GetNearbyAvailableClusters(pAvailableCluster, consideredClusters, clusterGroup);
 
     for (const Cluster *const pModifiedCluster : clusterGroup)
         modifiedClusters.insert(pModifiedCluster);
 
     const HitType hitType(LArClusterHelper::GetClusterHitType(pAvailableCluster));
     const HitType projectedHitType1((hitType == TPC_VIEW_U) ? TPC_VIEW_V : (hitType == TPC_VIEW_V) ? TPC_VIEW_W : TPC_VIEW_U);
     const HitType projectedHitType2((projectedHitType1 == TPC_VIEW_U) ? TPC_VIEW_V : (projectedHitType1 == TPC_VIEW_V) ? TPC_VIEW_W : TPC_VIEW_U);
     ClusterList projectedClusters1, projectedClusters2;
 
     for (const ParticleFlowObject *const pNearbyMuonPfo : nearbyMuonPfoVector)
     {
         const Cluster *const pProjectedCluster1(this->GetBestProjectedCluster(clusterGroup, pNearbyMuonPfo, projectedHitType1, true));
         const Cluster *const pProjectedCluster2(this->GetBestProjectedCluster(clusterGroup, pNearbyMuonPfo, projectedHitType2, true));
 
         if ((!pProjectedCluster1) && (!pProjectedCluster2))
             continue;
 
         ClusterList consideredClusters1;
         if (pProjectedCluster1)
             this->GetNearbyAvailableClusters(pProjectedCluster1, consideredClusters1, projectedClusters1);
 
         ClusterList consideredClusters2;
         if (pProjectedCluster2)
             this->GetNearbyAvailableClusters(pProjectedCluster2, consideredClusters2, projectedClusters2);
     }
 
     const Cluster *const pCluster1(this->MergeClusterGroup(clusterGroup));
     const Cluster *const pCluster2(this->MergeClusterGroup(projectedClusters1));
     const Cluster *const pCluster3(this->MergeClusterGroup(projectedClusters2));
 
     this->CreatePfo(pCluster1, pCluster2, pCluster3);
 }

void lar_content::OneViewDeltaRayMatchingAlgorithm::CreatePfo	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		const pandora::Cluster *const	pCluster3
	)

private

Create a pfo from the input clusters updating the cluster to pfo map accordingly.

Parameters

pCluster1	the address of the first cluster
pCluster2	the address of the second cluster
pCluster3	the address of the third cluster

Definition at line 416 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const PfoList *pPfoList(nullptr);
     std::string pfoListName;
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pPfoList, pfoListName));
 
     PandoraContentApi::ParticleFlowObject::Parameters pfoParameters;
     pfoParameters.m_particleId = E_MINUS;
     pfoParameters.m_charge = PdgTable::GetParticleCharge(E_MINUS);
     pfoParameters.m_mass = PdgTable::GetParticleMass(E_MINUS);
     pfoParameters.m_energy = 0.f;
     pfoParameters.m_momentum = CartesianVector(0.f, 0.f, 0.f);
 
     if (pCluster1)
         pfoParameters.m_clusterList.push_back(pCluster1);
 
     if (pCluster2)
         pfoParameters.m_clusterList.push_back(pCluster2);
 
     if (pCluster3)
         pfoParameters.m_clusterList.push_back(pCluster3);
 
     if (pfoParameters.m_clusterList.empty())
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     const ParticleFlowObject *pPfo(nullptr);
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::Create(*this, pfoParameters, pPfo));
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Pfo>(*this, m_outputPfoListName));
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Pfo>(*this, m_outputPfoListName));
 
     m_deltaRayMatchingContainers.AddClustersToPfoMaps(pPfo);
 }

const Cluster * lar_content::OneViewDeltaRayMatchingAlgorithm::GetBestProjectedCluster	(	const pandora::ClusterList &	deltaRayClusterGroup,
		const pandora::ParticleFlowObject *const	pNearbyMuonPfo,
		const pandora::HitType	hitType,
		const bool	findAvailable
	)

private

Get the best matched available or unavailable cluster of a remaining delta ray cluster group wrt a cosmic ray pfo.

Parameters

deltaRayClusterGroup	the input group of to be merged remaining delta ray clusters
pNearbyMuonPfo	the address of the nearby cosmic ray pfo
hitType	the hit type to project into
findAvailable	whether to search for available or unavailable delta ray clusters

Returns: whether the best matched cluster of the specified view

Definition at line 225 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     ClusterList muonClusterList;
     LArPfoHelper::GetClusters(pNearbyMuonPfo, hitType, muonClusterList);
 
     if (muonClusterList.size() != 1)
         return nullptr;
 
     const DeltaRayMatchingContainers::ClusterProximityMap &clusterProximityMap(m_deltaRayMatchingContainers.GetClusterProximityMap(hitType));
     auto muonProximityIter(clusterProximityMap.find(muonClusterList.front()));
 
     if (muonProximityIter == clusterProximityMap.end())
         return nullptr;
 
     float spanMinX(0.f), spanMaxX(0.f);
     this->GetClusterSpanX(deltaRayClusterGroup, spanMinX, spanMaxX);
 
     unsigned int highestHit(0);
     const Cluster *pProjectedCluster(nullptr);
 
     for (const Cluster *const pNearbyCluster : muonProximityIter->second)
     {
         if (findAvailable && !pNearbyCluster->IsAvailable())
             continue;
 
         if (!findAvailable && !this->IsDeltaRayPfo(pNearbyCluster))
             continue;
 
         float minX(0.f), maxX(0.f);
         pNearbyCluster->GetClusterSpanX(minX, maxX);
 
         if ((maxX < (spanMinX - m_overlapExtension)) || (minX > (spanMaxX + m_overlapExtension)))
             continue;
 
         if (pNearbyCluster->GetNCaloHits() > highestHit)
         {
             highestHit = pNearbyCluster->GetNCaloHits();
             pProjectedCluster = pNearbyCluster;
         }
     }
 
     return pProjectedCluster;
 }

void lar_content::OneViewDeltaRayMatchingAlgorithm::GetClusterSpanX	(	const pandora::ClusterList &	clusterList,
		float &	spanMinX,
		float &	spanMaxX
	)

private

Determine cluster span (in x) of a group of clusters.

Parameters

clusterList	the input list of clusters
spanMinX	the output minimum x value
spanMaxX	the output maximum x value

Definition at line 290 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     spanMinX = std::numeric_limits<float>::max();
     spanMaxX = -std::numeric_limits<float>::max();
 
     for (const Cluster *const pCluster : clusterList)
     {
         float minX(0.f), maxX(0.f);
         pCluster->GetClusterSpanX(minX, maxX);
 
         if (minX < spanMinX)
             spanMinX = minX;
 
         if (maxX > spanMaxX)
             spanMaxX = maxX;
     }
 }

const PfoList lar_content::OneViewDeltaRayMatchingAlgorithm::GetDeltaRayPfoList ( )

private

Get the input delta ray pfo list.

Returns: the input delta ray pfo list

Definition at line 85 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const PfoList *pDeltaRayPfoList(nullptr);
 
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, m_deltaRayPfoListName, pDeltaRayPfoList));
 
     if (!pDeltaRayPfoList)
         return PfoList();
 
     return *pDeltaRayPfoList;
 }

const ClusterList lar_content::OneViewDeltaRayMatchingAlgorithm::GetInputClusterList ( const pandora::HitType hitType )

private

Get the input cluster list of a given hit type.

Parameters

hitType the hit type of list to retrieve

Returns: the input cluster list of the specified hit type

Definition at line 52 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const std::string inputClusterListName(
         (hitType == TPC_VIEW_U) ? m_inputClusterListNameU : (hitType == TPC_VIEW_V) ? m_inputClusterListNameV : m_inputClusterListNameW);
 
     const ClusterList *pInputClusterList(nullptr);
 
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, inputClusterListName, pInputClusterList));
 
     if (!pInputClusterList)
         return ClusterList();
 
     return *pInputClusterList;
 }

const PfoList lar_content::OneViewDeltaRayMatchingAlgorithm::GetMuonPfoList ( )

private

Get the input cosmic ray pfo list.

Returns: the input cosmic ray pfo list

Definition at line 70 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const PfoList *pMuonPfoList(nullptr);
 
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, m_muonPfoListName, pMuonPfoList));
 
     if (!pMuonPfoList)
         return PfoList();
 
     return *pMuonPfoList;
 }

void lar_content::OneViewDeltaRayMatchingAlgorithm::GetNearbyAvailableClusters	(	const pandora::Cluster *const	pCluster,
		pandora::ClusterList &	consideredClusters,
		pandora::ClusterList &	foundClusters
	)

private

In the view of the input available cluster, gather nearby available clusters.

Parameters

pCluster	the input available cluster
consideredClusters	the list of investigated clusters
foundClusters	the output list of nearby available clusters (including the available cluster)

Definition at line 349 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
     const DeltaRayMatchingContainers::ClusterProximityMap &clusterProximityMap(m_deltaRayMatchingContainers.GetClusterProximityMap(hitType));
 
     consideredClusters.push_back(pCluster);
 
     if (!pCluster->IsAvailable())
         return;
 
     if (std::find(foundClusters.begin(), foundClusters.end(), pCluster) == foundClusters.end())
         foundClusters.push_back(pCluster);
 
     const DeltaRayMatchingContainers::ClusterProximityMap::const_iterator proximityIter(clusterProximityMap.find(pCluster));
 
     if (proximityIter == clusterProximityMap.end())
         return;
 
     for (const Cluster *const pNearbyCluster : proximityIter->second)
     {
         if (!pNearbyCluster->IsAvailable())
             continue;
 
         if (std::find(consideredClusters.begin(), consideredClusters.end(), pNearbyCluster) != consideredClusters.end())
             continue;
 
         if (std::find(foundClusters.begin(), foundClusters.end(), pNearbyCluster) != foundClusters.end())
             continue;
 
         this->GetNearbyAvailableClusters(pNearbyCluster, consideredClusters, foundClusters);
     }
 }

bool lar_content::OneViewDeltaRayMatchingAlgorithm::IsDeltaRayPfo ( const pandora::Cluster *const pCluster )

private

Determine whether an input cluster belongs to a delta ray pfo.

Parameters

pCluster the address of the input cluster

Returns: whether the input cluster belongs to a delta ray pfo

Definition at line 272 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
     const DeltaRayMatchingContainers::ClusterToPfoMap &clusterToPfoMap(m_deltaRayMatchingContainers.GetClusterToPfoMap(hitType));
 
     const DeltaRayMatchingContainers::ClusterToPfoMap::const_iterator iter(clusterToPfoMap.find(pCluster));
 
     if (iter == clusterToPfoMap.end())
         return false;
 
     const ParticleFlowObject *const pDeltaRayPfo(iter->second);
     const PfoList &deltaRayPfoList(this->GetDeltaRayPfoList());
 
     return (std::find(deltaRayPfoList.begin(), deltaRayPfoList.end(), pDeltaRayPfo) != deltaRayPfoList.end());
 }

bool lar_content::OneViewDeltaRayMatchingAlgorithm::IsMuonPfo ( const pandora::Cluster *const pCluster )

private

Determine whether an input cluster belongs to a cosmic ray pfo.

Parameters

pCluster the address of the input cluster

Returns: whether the input cluster belongs to a cosmic ray pfo

Definition at line 174 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
     const DeltaRayMatchingContainers::ClusterToPfoMap &clusterToPfoMap(m_deltaRayMatchingContainers.GetClusterToPfoMap(hitType));
     const DeltaRayMatchingContainers::ClusterToPfoMap::const_iterator iter(clusterToPfoMap.find(pCluster));
 
     if (iter == clusterToPfoMap.end())
         return false;
 
     const ParticleFlowObject *const pPfo(iter->second);
     const PfoList &muonPfoList(this->GetMuonPfoList());
 
     return (std::find(muonPfoList.begin(), muonPfoList.end(), pPfo) != muonPfoList.end());
 }

const Cluster * lar_content::OneViewDeltaRayMatchingAlgorithm::MergeClusterGroup ( const pandora::ClusterList & clusterGroup )

private

Merge a collection of available clusters together updating hit containers accordingly.

Parameters

clusterGroup	the input group of clusters to merge
the	merged cluster

Definition at line 384 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     if (clusterGroup.empty())
         return nullptr;
 
     const Cluster *const pClusterToEnlarge(clusterGroup.front());
 
     if (clusterGroup.size() == 1)
         return pClusterToEnlarge;
 
     const HitType hitType(LArClusterHelper::GetClusterHitType(pClusterToEnlarge));
     const std::string inputClusterListName(
         (hitType == TPC_VIEW_U) ? m_inputClusterListNameU : (hitType == TPC_VIEW_V) ? m_inputClusterListNameV : m_inputClusterListNameW);
 
     for (const Cluster *const pClusterToDelete : clusterGroup)
     {
         m_deltaRayMatchingContainers.RemoveClusterFromContainers(pClusterToDelete);
 
         if (pClusterToDelete != pClusterToEnlarge)
         {
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*this, inputClusterListName));
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*this, pClusterToEnlarge, pClusterToDelete));
         }
     }
 
     m_deltaRayMatchingContainers.AddClustersToContainers({pClusterToEnlarge}, {nullptr});
 
     return pClusterToEnlarge;
 }

void lar_content::OneViewDeltaRayMatchingAlgorithm::PerformOneViewMatching ( const pandora::HitType hitType )

private

Use nearby muon pfos to project into other views and attempt to match the remaining delta ray clusters.

Parameters

hitType the hit type of the input cluster and of the map to add to

Definition at line 100 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const DeltaRayMatchingContainers::ClusterProximityMap &clusterProximityMap(m_deltaRayMatchingContainers.GetClusterProximityMap(hitType));
     const DeltaRayMatchingContainers::ClusterToPfoMap &clusterToPfoMap(m_deltaRayMatchingContainers.GetClusterToPfoMap(hitType));
     ClusterVector availableClusterList;
 
     for (auto &entry : clusterProximityMap)
     {
         if (entry.first->IsAvailable())
             availableClusterList.push_back(entry.first);
     }
 
     std::sort(availableClusterList.begin(), availableClusterList.end(), LArClusterHelper::SortByNHits);
 
     ClusterSet modifiedClusters;
 
     for (const Cluster *const pAvailableCluster : availableClusterList)
     {
         if (modifiedClusters.count(pAvailableCluster))
             continue;
 
         const DeltaRayMatchingContainers::ClusterProximityMap::const_iterator iter(clusterProximityMap.find(pAvailableCluster));
 
         // ATTN: Map will update during loop
         if (iter == clusterProximityMap.end())
             continue;
 
         bool found(false);
         const ClusterList &nearbyClusters(clusterProximityMap.at(pAvailableCluster));
         PfoVector nearbyMuonPfoVector;
 
         do
         {
             found = false;
 
             const ParticleFlowObject *pClosestMuonPfo(nullptr);
             float closestDistance(std::numeric_limits<float>::max());
 
             for (const Cluster *const pNearbyCluster : nearbyClusters)
             {
                 if (!this->IsMuonPfo(pNearbyCluster))
                     continue;
 
                 if (std::find(nearbyMuonPfoVector.begin(), nearbyMuonPfoVector.end(), clusterToPfoMap.at(pNearbyCluster)) !=
                     nearbyMuonPfoVector.end())
                     continue;
 
                 found = true;
 
                 const float separation(LArClusterHelper::GetClosestDistance(pNearbyCluster, pAvailableCluster));
 
                 if (separation < closestDistance)
                 {
                     closestDistance = separation;
                     pClosestMuonPfo = clusterToPfoMap.at(pNearbyCluster);
                 }
             }
 
             if (pClosestMuonPfo)
                 nearbyMuonPfoVector.push_back(pClosestMuonPfo);
         } while (found);
 
         if (nearbyMuonPfoVector.empty())
             continue;
 
         if (this->AddIntoExistingDeltaRay(pAvailableCluster, nearbyMuonPfoVector))
             continue;
 
         this->CreateDeltaRay(pAvailableCluster, nearbyMuonPfoVector, modifiedClusters);
     }
 }

void lar_content::OneViewDeltaRayMatchingAlgorithm::PerformRecovery ( const pandora::HitType hitType )

private

Create a delta ray pfo from any remaining, significant clusters.

Parameters

hitType the view to run in

Definition at line 452 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const ClusterList &inputClusterList(this->GetInputClusterList(hitType));
 
     for (const Cluster *const pCluster : inputClusterList)
     {
         if (!pCluster->IsAvailable())
             continue;
 
         if (pCluster->GetNCaloHits() < m_minClusterHits)
             continue;
 
         this->CreatePfo(pCluster, nullptr, nullptr);
     }
 }

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

private

Definition at line 470 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "MuonPfoListName", m_muonPfoListName));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "DeltaRayPfoListName", m_deltaRayPfoListName));
 
     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(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputPfoListName", m_outputPfoListName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "SearchRegion1D", m_deltaRayMatchingContainers.m_searchRegion1D));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "OverlapExtension", m_overlapExtension));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterHits", m_minClusterHits));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::OneViewDeltaRayMatchingAlgorithm::Run ( )

private

Definition at line 29 of file OneViewDeltaRayMatchingAlgorithm.cc.

 {
     const PfoList muonPfoList(this->GetMuonPfoList());
     PfoList allPfoList(this->GetDeltaRayPfoList());
 
     allPfoList.insert(allPfoList.end(), muonPfoList.begin(), muonPfoList.end());
 
     m_deltaRayMatchingContainers.FillContainers(
         allPfoList, this->GetInputClusterList(TPC_VIEW_U), this->GetInputClusterList(TPC_VIEW_V), this->GetInputClusterList(TPC_VIEW_W));
 
     for (const HitType hitType : {TPC_VIEW_U, TPC_VIEW_V, TPC_VIEW_W})
         this->PerformOneViewMatching(hitType);
 
     for (const HitType hitType : {TPC_VIEW_U, TPC_VIEW_V, TPC_VIEW_W})
         this->PerformRecovery(hitType);
 
     m_deltaRayMatchingContainers.ClearContainers();
 
     return STATUS_CODE_SUCCESS;
 }