lar_content::ClusterAssociationAlgorithm Class Reference

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 pClusterToEnlarge, const pandora::Cluster *const pClusterToDelete, const bool isForwardMerge, 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 117 of file ClusterAssociationAlgorithm.cc.

References m_mergeMade, NavigateAlongAssociations(), lar_content::LArClusterHelper::SortByNHits(), and UpdateForAmbiguousMerge().

Referenced by Run().

{
    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(pCluster, *dIter, isForward, clusterAssociationMap);
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*this, pCluster, *dIter));
        m_mergeMade = true;
        *dIter = NULL;
    } 
}

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, and lar_content::CrossGapsAssociationAlgorithm.

Referenced by Run().

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, and lar_content::CrossGapsAssociationAlgorithm.

Referenced by NavigateAlongAssociations().

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 264 of file ClusterAssociationAlgorithm.cc.

References IsExtremalCluster().

Referenced by AmbiguousPropagation().

{
    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, and lar_content::CrossGapsAssociationAlgorithm.

Referenced by Run().

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

protectedvirtual

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

Definition at line 287 of file ClusterAssociationAlgorithm.cc.

References m_resolveAmbiguousAssociations.

Referenced by lar_content::LongitudinalAssociationAlgorithm::ReadSettings(), lar_content::CrossGapsAssociationAlgorithm::ReadSettings(), and lar_content::TransverseAssociationAlgorithm::ReadSettings().

{
    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 28 of file ClusterAssociationAlgorithm.cc.

References AmbiguousPropagation(), GetListOfCleanClusters(), m_mergeMade, m_resolveAmbiguousAssociations, PopulateClusterAssociationMap(), and UnambiguousPropagation().

{
    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 mapIter = clusterAssociationMap.find(pCluster);

            if (clusterAssociationMap.end() == mapIter)
                continue;

            if (mapIter->second.m_backwardAssociations.empty() && !mapIter->second.m_forwardAssociations.empty())
                this->AmbiguousPropagation(pCluster, true, clusterAssociationMap);

            if (mapIter->second.m_forwardAssociations.empty() && !mapIter->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 84 of file ClusterAssociationAlgorithm.cc.

References m_mergeMade, and UpdateForUnambiguousMerge().

Referenced by Run().

{
    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  pClusterToEnlarge, const pandora::Cluster *const  pClusterToDelete, const bool  isForwardMerge, ClusterAssociationMap &  clusterAssociationMap  ) const

private

Update cluster association map to reflect an ambiguous 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 197 of file ClusterAssociationAlgorithm.cc.

References UpdateForUnambiguousMerge().

Referenced by AmbiguousPropagation().

{
    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 &clusterSetEnlarge(isForwardMerge ? iterEnlarge->second.m_forwardAssociations : iterEnlarge->second.m_backwardAssociations);
    ClusterSet &clusterSetDelete(isForwardMerge ? iterDelete->second.m_backwardAssociations : iterDelete->second.m_forwardAssociations);

    for (ClusterSet::iterator iter = clusterSetEnlarge.begin(); iter != clusterSetEnlarge.end();)
    {
        if ((*iter) != pClusterToDelete)
        {
            ClusterAssociationMap::iterator iterAssociation = clusterAssociationMap.find(*iter);

            if (clusterAssociationMap.end() == iterAssociation)
                throw StatusCodeException(STATUS_CODE_NOT_FOUND);

            ClusterSet &associatedClusterSet(isForwardMerge ? iterAssociation->second.m_backwardAssociations : iterAssociation->second.m_forwardAssociations);

            ClusterSet::iterator enlargeIter = associatedClusterSet.find(pClusterToEnlarge);

            if (associatedClusterSet.end() == enlargeIter)
                throw StatusCodeException(STATUS_CODE_NOT_FOUND);

            associatedClusterSet.erase(enlargeIter);
            clusterSetEnlarge.erase(iter++);
        }
        else
        {
            ++iter;
        }
    }

    for (ClusterSet::iterator iter = clusterSetDelete.begin(); iter != clusterSetDelete.end();)
    {
        if ((*iter) != pClusterToEnlarge)
        {
            ClusterAssociationMap::iterator iterAssociation = clusterAssociationMap.find(*iter);

            if (clusterAssociationMap.end() == iterAssociation)
                throw StatusCodeException(STATUS_CODE_NOT_FOUND);

            ClusterSet &associatedClusterSet(isForwardMerge ? iterAssociation->second.m_forwardAssociations : iterAssociation->second.m_backwardAssociations);

            ClusterSet::iterator deleteIter = associatedClusterSet.find(pClusterToDelete);

            if (associatedClusterSet.end() == deleteIter)
                throw StatusCodeException(STATUS_CODE_NOT_FOUND);

            associatedClusterSet.erase(deleteIter);
            clusterSetDelete.erase(iter++);
        }
        else
        {
            ++iter;
        }
    }

    return this->UpdateForUnambiguousMerge(pClusterToEnlarge, pClusterToDelete, isForwardMerge, clusterAssociationMap);
}

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 159 of file ClusterAssociationAlgorithm.cc.

Referenced by UnambiguousPropagation(), and UpdateForAmbiguousMerge().

{
    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 125 of file ClusterAssociationAlgorithm.h.

Referenced by AmbiguousPropagation(), Run(), and UnambiguousPropagation().

bool lar_content::ClusterAssociationAlgorithm::m_resolveAmbiguousAssociations

private

Whether to resolve ambiguous associations.

Definition at line 127 of file ClusterAssociationAlgorithm.h.

Referenced by ReadSettings(), and Run().

---

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

• larpandoracontent/v03_13_02/source/larpandoracontent/LArTwoDReco/LArClusterAssociation/ClusterAssociationAlgorithm.h
• larpandoracontent/v03_13_02/source/larpandoracontent/LArTwoDReco/LArClusterAssociation/ClusterAssociationAlgorithm.cc