ClusterAssociationAlgorithm class. More...

#include <ClusterAssociationAlgorithm.h>

Inheritance diagram for lar_content::ClusterAssociationAlgorithm:

Classes
class	ClusterAssociation
	ClusterAssociation class. More...

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

Protected Types
typedef std::unordered_map < const pandora::Cluster *, ClusterAssociation >	ClusterAssociationMap

Protected Member Functions
virtual pandora::StatusCode	Run ()

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

virtual void	GetListOfCleanClusters (const pandora::ClusterList *const pClusterList, pandora::ClusterVector &clusterVector) const =0
	Populate cluster vector with subset of cluster list, containing clusters judged to be clean. More...

virtual void	PopulateClusterAssociationMap (const pandora::ClusterVector &clusterVector, ClusterAssociationMap &clusterAssociationMap) const =0
	Populate the cluster association map. More...

virtual bool	IsExtremalCluster (const bool isForward, const pandora::Cluster const pCurrentCluster, const pandora::Cluster const pTestCluster) const =0
	Determine which of two clusters is extremal. More...

Private Member Functions
void	UnambiguousPropagation (const pandora::Cluster *const pCluster, const bool isForward, ClusterAssociationMap &clusterAssociationMap) const
	Unambiguous propagation. More...

void	AmbiguousPropagation (const pandora::Cluster *const pCluster, const bool isForward, ClusterAssociationMap &clusterAssociationMap) const
	Ambiguous propagation. More...

void	UpdateForUnambiguousMerge (const pandora::Cluster const pClusterToEnlarge, const pandora::Cluster const pClusterToDelete, const bool isForwardMerge, ClusterAssociationMap &clusterAssociationMap) const
	Update cluster association map to reflect an unambiguous cluster merge. More...

void	UpdateForAmbiguousMerge (const pandora::Cluster *const pCluster, ClusterAssociationMap &clusterAssociationMap) const
	Update cluster association map to reflect an ambiguous cluster merge. More...

void	NavigateAlongAssociations (const ClusterAssociationMap &clusterAssociationMap, const pandora::Cluster const pCluster, const bool isForward, const pandora::Cluster &pExtremalCluster, pandora::ClusterSet &clusterSet) const
	Navigate along cluster associations, from specified cluster, in specified direction. More...

Private Attributes
bool	m_mergeMade

bool	m_resolveAmbiguousAssociations
	Whether to resolve ambiguous associations. More...

Detailed Description

ClusterAssociationAlgorithm class.

Definition at line 21 of file ClusterAssociationAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, ClusterAssociation> lar_content::ClusterAssociationAlgorithm::ClusterAssociationMap

protected

Definition at line 43 of file ClusterAssociationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::ClusterAssociationAlgorithm::ClusterAssociationAlgorithm ( )

Default constructor.

Definition at line 20 of file ClusterAssociationAlgorithm.cc.

                                                          : m_mergeMade(false), m_resolveAmbiguousAssociations(true)
 {
 }

Member Function Documentation

void lar_content::ClusterAssociationAlgorithm::AmbiguousPropagation	(	const pandora::Cluster *const	pCluster,
		const bool	isForward,
		ClusterAssociationMap &	clusterAssociationMap
	)		const

private

Ambiguous propagation.

Parameters

pCluster	address of the cluster to propagate
isForward	whether propagation direction is forward
clusterAssociationMap	the cluster association map

Definition at line 121 of file ClusterAssociationAlgorithm.cc.

 {
     ClusterAssociationMap::iterator cIter = clusterAssociationMap.find(pCluster);
 
     if (clusterAssociationMap.end() == cIter)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     const Cluster *pExtremalCluster = pCluster;
 
     ClusterSet firstClusterSet;
     this->NavigateAlongAssociations(clusterAssociationMap, pCluster, isForward, pExtremalCluster, firstClusterSet);
 
     ClusterSet secondClusterSet;
     this->NavigateAlongAssociations(clusterAssociationMap, pExtremalCluster, !isForward, pExtremalCluster, secondClusterSet);
 
     ClusterVector daughterClusterVector;
 
     if (pCluster == pExtremalCluster)
     {
         for (const Cluster *const pFirstCluster : firstClusterSet)
         {
             if ((pCluster != pFirstCluster) && (secondClusterSet.count(pFirstCluster)) &&
                 (daughterClusterVector.end() == std::find(daughterClusterVector.begin(), daughterClusterVector.end(), pFirstCluster)))
             {
                 daughterClusterVector.push_back(pFirstCluster);
             }
         }
     }
 
     std::sort(daughterClusterVector.begin(), daughterClusterVector.end(), LArClusterHelper::SortByNHits);
 
     for (ClusterVector::iterator dIter = daughterClusterVector.begin(), dIterEnd = daughterClusterVector.end(); dIter != dIterEnd; ++dIter)
     {
         this->UpdateForAmbiguousMerge(*dIter, clusterAssociationMap);
 
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*this, pCluster, *dIter));
         m_mergeMade = true;
         *dIter = NULL;
     }
 
     this->UpdateForAmbiguousMerge(pCluster, clusterAssociationMap);
 }

virtual void lar_content::ClusterAssociationAlgorithm::GetListOfCleanClusters	(	const pandora::ClusterList *const	pClusterList,
		pandora::ClusterVector &	clusterVector
	)		const

protectedpure virtual

Populate cluster vector with subset of cluster list, containing clusters judged to be clean.

Parameters

pClusterList	address of the cluster list
clusterVector	to receive the populated cluster vector

Implemented in lar_content::TransverseAssociationAlgorithm, lar_content::LongitudinalAssociationAlgorithm, lar_content::CrossGapsAssociationAlgorithm, and lar_content::HitWidthClusterMergingAlgorithm.

virtual bool lar_content::ClusterAssociationAlgorithm::IsExtremalCluster	(	const bool	isForward,
		const pandora::Cluster *const	pCurrentCluster,
		const pandora::Cluster *const	pTestCluster
	)		const

protectedpure virtual

Determine which of two clusters is extremal.

Parameters

isForward	whether propagation direction is forward
pCurrentCluster	current extremal cluster
pTestCluster	potential extremal cluster

Returns: boolean

Implemented in lar_content::TransverseAssociationAlgorithm, lar_content::LongitudinalAssociationAlgorithm, lar_content::CrossGapsAssociationAlgorithm, and lar_content::HitWidthClusterMergingAlgorithm.

void lar_content::ClusterAssociationAlgorithm::NavigateAlongAssociations	(	const ClusterAssociationMap &	clusterAssociationMap,
		const pandora::Cluster *const	pCluster,
		const bool	isForward,
		const pandora::Cluster *&	pExtremalCluster,
		pandora::ClusterSet &	clusterSet
	)		const

private

Navigate along cluster associations, from specified cluster, in specified direction.

Parameters

clusterAssociationMap	the cluster association map
pCluster	address of cluster with which to begin search
isForward	whether propagation direction is forward
pExtremalCluster	to receive the extremal cluster
clusterSet	to receive set of clusters traversed

Definition at line 231 of file ClusterAssociationAlgorithm.cc.

 {
     ClusterAssociationMap::const_iterator iterAssociation = clusterAssociationMap.find(pCluster);
 
     if (clusterAssociationMap.end() == iterAssociation)
         throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
     (void)clusterSet.insert(pCluster);
 
     if ((pCluster != pExtremalCluster) && this->IsExtremalCluster(isForward, pExtremalCluster, pCluster))
         pExtremalCluster = pCluster;
 
     const ClusterSet &associatedClusterSet(isForward ? iterAssociation->second.m_forwardAssociations : iterAssociation->second.m_backwardAssociations);
 
     for (ClusterSet::const_iterator iter = associatedClusterSet.begin(), iterEnd = associatedClusterSet.end(); iter != iterEnd; ++iter)
     {
         this->NavigateAlongAssociations(clusterAssociationMap, *iter, isForward, pExtremalCluster, clusterSet);
     }
 }

virtual void lar_content::ClusterAssociationAlgorithm::PopulateClusterAssociationMap	(	const pandora::ClusterVector &	clusterVector,
		ClusterAssociationMap &	clusterAssociationMap
	)		const

protectedpure virtual

Populate the cluster association map.

Parameters

clusterVector	the cluster vector
clusterAssociationMap	to receive the populated cluster association map

Implemented in lar_content::TransverseAssociationAlgorithm, lar_content::LongitudinalAssociationAlgorithm, lar_content::CrossGapsAssociationAlgorithm, and lar_content::HitWidthClusterMergingAlgorithm.

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

protectedvirtual

Reimplemented in lar_content::HitWidthClusterMergingAlgorithm, lar_content::TransverseAssociationAlgorithm, lar_content::CrossGapsAssociationAlgorithm, and lar_content::LongitudinalAssociationAlgorithm.

Definition at line 254 of file ClusterAssociationAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ResolveAmbiguousAssociations", m_resolveAmbiguousAssociations));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::ClusterAssociationAlgorithm::Run ( )

protectedvirtual

Definition at line 26 of file ClusterAssociationAlgorithm.cc.

 {
     const ClusterList *pClusterList = NULL;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pClusterList));
 
     ClusterVector clusterVector;
     this->GetListOfCleanClusters(pClusterList, clusterVector);
 
     ClusterAssociationMap clusterAssociationMap;
     this->PopulateClusterAssociationMap(clusterVector, clusterAssociationMap);
 
     m_mergeMade = true;
 
     while (m_mergeMade)
     {
         // Unambiguous propagation
         while (m_mergeMade)
         {
             m_mergeMade = false;
 
             for (const Cluster *const pCluster : clusterVector)
             {
                 // ATTN The clusterVector may end up with dangling pointers; only protected by this check against managed cluster list
                 if (pClusterList->end() == std::find(pClusterList->begin(), pClusterList->end(), pCluster))
                     continue;
 
                 this->UnambiguousPropagation(pCluster, true, clusterAssociationMap);
                 this->UnambiguousPropagation(pCluster, false, clusterAssociationMap);
             }
         }
 
         if (!m_resolveAmbiguousAssociations)
             continue;
 
         // Propagation with ambiguities
         for (const Cluster *const pCluster : clusterVector)
         {
             // ATTN The clusterVector may end up with dangling pointers; only protected by this check against up-to-date association list
             ClusterAssociationMap::const_iterator mapIterFwd = clusterAssociationMap.find(pCluster);
 
             if (clusterAssociationMap.end() == mapIterFwd)
                 continue;
 
             if (mapIterFwd->second.m_backwardAssociations.empty() && !mapIterFwd->second.m_forwardAssociations.empty())
                 this->AmbiguousPropagation(pCluster, true, clusterAssociationMap);
 
             ClusterAssociationMap::const_iterator mapIterBwd = clusterAssociationMap.find(pCluster);
 
             if (clusterAssociationMap.end() == mapIterBwd)
                 continue;
 
             if (mapIterBwd->second.m_forwardAssociations.empty() && !mapIterBwd->second.m_backwardAssociations.empty())
                 this->AmbiguousPropagation(pCluster, false, clusterAssociationMap);
         }
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ClusterAssociationAlgorithm::UnambiguousPropagation	(	const pandora::Cluster *const	pCluster,
		const bool	isForward,
		ClusterAssociationMap &	clusterAssociationMap
	)		const

private

Unambiguous propagation.

Parameters

pCluster	address of the cluster to propagate
isForward	whether propagation direction is forward
clusterAssociationMap	the cluster association map

Definition at line 87 of file ClusterAssociationAlgorithm.cc.

 {
     const Cluster *const pClusterToEnlarge = pCluster;
     ClusterAssociationMap::iterator iterEnlarge = clusterAssociationMap.find(pClusterToEnlarge);
 
     if (clusterAssociationMap.end() == iterEnlarge)
         return;
 
     ClusterSet &clusterSetEnlarge(isForward ? iterEnlarge->second.m_forwardAssociations : iterEnlarge->second.m_backwardAssociations);
 
     if (clusterSetEnlarge.size() != 1)
         return;
 
     const Cluster *const pClusterToDelete = *(clusterSetEnlarge.begin());
     ClusterAssociationMap::iterator iterDelete = clusterAssociationMap.find(pClusterToDelete);
 
     if (clusterAssociationMap.end() == iterDelete)
         return;
 
     ClusterSet &clusterSetDelete(isForward ? iterDelete->second.m_backwardAssociations : iterDelete->second.m_forwardAssociations);
 
     if (clusterSetDelete.size() != 1)
         return;
 
     this->UpdateForUnambiguousMerge(pClusterToEnlarge, pClusterToDelete, isForward, clusterAssociationMap);
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*this, pClusterToEnlarge, pClusterToDelete));
     m_mergeMade = true;
 
     this->UnambiguousPropagation(pClusterToEnlarge, isForward, clusterAssociationMap);
 }

void lar_content::ClusterAssociationAlgorithm::UpdateForAmbiguousMerge	(	const pandora::Cluster *const	pCluster,
		ClusterAssociationMap &	clusterAssociationMap
	)		const

private

Update cluster association map to reflect an ambiguous cluster merge.

Parameters

pCluster	address of the cluster to be cleared
clusterAssociationMap	the cluster association map

Definition at line 204 of file ClusterAssociationAlgorithm.cc.

 {
     ClusterAssociationMap::iterator cIter = clusterAssociationMap.find(pCluster);
 
     if (clusterAssociationMap.end() == cIter)
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     for (ClusterAssociationMap::iterator mIter = clusterAssociationMap.begin(), mIterEnd = clusterAssociationMap.end(); mIter != mIterEnd; ++mIter)
     {
         ClusterSet &forwardClusters = mIter->second.m_forwardAssociations;
         ClusterSet &backwardClusters = mIter->second.m_backwardAssociations;
 
         ClusterSet::iterator fIter = forwardClusters.find(pCluster);
         ClusterSet::iterator bIter = backwardClusters.find(pCluster);
 
         if (forwardClusters.end() != fIter)
             forwardClusters.erase(fIter);
 
         if (backwardClusters.end() != bIter)
             backwardClusters.erase(bIter);
     }
 
     clusterAssociationMap.erase(pCluster);
 }

void lar_content::ClusterAssociationAlgorithm::UpdateForUnambiguousMerge	(	const pandora::Cluster *const	pClusterToEnlarge,
		const pandora::Cluster *const	pClusterToDelete,
		const bool	isForwardMerge,
		ClusterAssociationMap &	clusterAssociationMap
	)		const

private

Update cluster association map to reflect an unambiguous cluster merge.

Parameters

pClusterToEnlarge	address of the cluster to be enlarged
pClusterToDelete	address of the cluster to be deleted
isForwardMerge	whether merge is forward (pClusterToEnlarge is forward-associated with pClusterToDelete)
clusterAssociationMap	the cluster association map

Definition at line 166 of file ClusterAssociationAlgorithm.cc.

 {
     ClusterAssociationMap::iterator iterEnlarge = clusterAssociationMap.find(pClusterToEnlarge);
     ClusterAssociationMap::iterator iterDelete = clusterAssociationMap.find(pClusterToDelete);
 
     if ((clusterAssociationMap.end() == iterEnlarge) || (clusterAssociationMap.end() == iterDelete))
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     ClusterSet &clusterSetToMove(isForwardMerge ? iterDelete->second.m_forwardAssociations : iterDelete->second.m_backwardAssociations);
     ClusterSet &clusterSetToReplace(isForwardMerge ? iterEnlarge->second.m_forwardAssociations : iterEnlarge->second.m_backwardAssociations);
     clusterSetToReplace = clusterSetToMove;
     clusterAssociationMap.erase(iterDelete);
 
     for (ClusterAssociationMap::iterator iter = clusterAssociationMap.begin(), iterEnd = clusterAssociationMap.end(); iter != iterEnd; ++iter)
     {
         ClusterSet &forwardClusters = iter->second.m_forwardAssociations;
         ClusterSet &backwardClusters = iter->second.m_backwardAssociations;
 
         ClusterSet::iterator forwardIter = forwardClusters.find(pClusterToDelete);
         ClusterSet::iterator backwardIter = backwardClusters.find(pClusterToDelete);
 
         if (forwardClusters.end() != forwardIter)
         {
             forwardClusters.erase(forwardIter);
             forwardClusters.insert(pClusterToEnlarge);
         }
 
         if (backwardClusters.end() != backwardIter)
         {
             backwardClusters.erase(backwardIter);
             backwardClusters.insert(pClusterToEnlarge);
         }
     }
 }

Member Data Documentation

bool lar_content::ClusterAssociationAlgorithm::m_mergeMade

mutableprivate

Definition at line 123 of file ClusterAssociationAlgorithm.h.

bool lar_content::ClusterAssociationAlgorithm::m_resolveAmbiguousAssociations

private

Whether to resolve ambiguous associations.

Definition at line 125 of file ClusterAssociationAlgorithm.h.

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

Classes

Public Member Functions

Protected Types

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation