lar_content::BranchGrowingAlgorithm Class Reference

BranchGrowingAlgorithm class. More...

#include <BranchGrowingAlgorithm.h>

Inheritance diagram for lar_content::BranchGrowingAlgorithm:

Classes
class	Association
	Association class. More...

Protected Types
enum	AssociationType { NONE = 0, SINGLE_ORDER = 1, STANDARD = 2, STRONG = 3 }
	AssociationType enum. More...
typedef std::unordered_map< const pandora::Cluster *, Association >	ClusterAssociationMap
typedef std::unordered_map< const pandora::Cluster *, ClusterAssociationMap >	ClusterUsageMap
typedef std::unordered_map< const pandora::Cluster *, pandora::ClusterVector >	SeedAssociationList

Protected Member Functions
virtual AssociationType	AreClustersAssociated (const pandora::Cluster *const pClusterSeed, const pandora::Cluster *const pCluster) const =0
	Determine whether two clusters are associated. More...
void	FindAssociatedClusters (const pandora::Cluster *const pParticleSeed, pandora::ClusterVector &candidateClusters, ClusterUsageMap &forwardUsageMap, ClusterUsageMap &backwardUsageMap) const
	Find clusters associated with a particle seed. More...
void	IdentifyClusterMerges (const pandora::ClusterVector &particleSeedVector, const ClusterUsageMap &backwardUsageMap, SeedAssociationList &seedAssociationList) const
	Identify cluster merges. More...
virtual pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Detailed Description

BranchGrowingAlgorithm class.

Definition at line 21 of file BranchGrowingAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, Association> lar_content::BranchGrowingAlgorithm::ClusterAssociationMap

protected

Definition at line 87 of file BranchGrowingAlgorithm.h.

typedef std::unordered_map<const pandora::Cluster *, ClusterAssociationMap> lar_content::BranchGrowingAlgorithm::ClusterUsageMap

protected

Definition at line 88 of file BranchGrowingAlgorithm.h.

typedef std::unordered_map<const pandora::Cluster *, pandora::ClusterVector> lar_content::BranchGrowingAlgorithm::SeedAssociationList

protected

Definition at line 111 of file BranchGrowingAlgorithm.h.

Member Enumeration Documentation

enum lar_content::BranchGrowingAlgorithm::AssociationType

protected

AssociationType enum.

Enumerator
NONE
SINGLE_ORDER
STANDARD
STRONG

Definition at line 27 of file BranchGrowingAlgorithm.h.

    {
        NONE = 0,
        SINGLE_ORDER = 1,
        STANDARD = 2,
        STRONG = 3
    };

Member Function Documentation

virtual AssociationType lar_content::BranchGrowingAlgorithm::AreClustersAssociated ( const pandora::Cluster *const  pClusterSeed, const pandora::Cluster *const  pCluster  ) const

protectedpure virtual

Determine whether two clusters are associated.

Parameters

pClusterSeed	address of cluster seed (may be daughter of primary seed)
pCluster	address of cluster

Returns

the association type

Implemented in lar_content::ShowerGrowingAlgorithm.

void lar_content::BranchGrowingAlgorithm::FindAssociatedClusters ( const pandora::Cluster *const  pParticleSeed, pandora::ClusterVector &  candidateClusters, ClusterUsageMap &  forwardUsageMap, ClusterUsageMap &  backwardUsageMap  ) const

protected

Find clusters associated with a particle seed.

Parameters

pParticleSeed	address of the particle seed
candidateClusters	list of clusters which may be associated with seed
forwardUsageMap	the particle seed usage map
backwardUsageMap	the cluster usage map

Definition at line 20 of file BranchGrowingAlgorithm.cc.

{
    ClusterVector currentSeedAssociations, newSeedAssociations;
    currentSeedAssociations.push_back(pParticleSeed);

    unsigned int associationOrder(1);

    while (!currentSeedAssociations.empty())
    {
        for (ClusterVector::iterator iterI = candidateClusters.begin(), iterIEnd = candidateClusters.end(); iterI != iterIEnd; ++iterI)
        {
            const Cluster *const pCandidateCluster = *iterI;

            if (NULL == pCandidateCluster)
                continue;

            for (ClusterVector::iterator iterJ = currentSeedAssociations.begin(), iterJEnd = currentSeedAssociations.end(); iterJ != iterJEnd; ++iterJ)
            {
                const Cluster *const pAssociatedCluster = *iterJ;

                const AssociationType associationType(this->AreClustersAssociated(pAssociatedCluster, pCandidateCluster));

                if (NONE == associationType)
                    continue;

                // Check we store best association between this seed and candidate
                Association association(associationOrder, associationType);
                const Association &existingAssociation = forwardUsageMap[pParticleSeed][pCandidateCluster];

                if (association.GetType() > existingAssociation.GetType())
                {
                    // If not first association, check strength of previous association in chain
                    if (pParticleSeed != pAssociatedCluster)
                        association.SetType(std::min(association.GetType(), backwardUsageMap[pAssociatedCluster][pParticleSeed].GetType()));

                    forwardUsageMap[pParticleSeed][pCandidateCluster] = association;
                    backwardUsageMap[pCandidateCluster][pParticleSeed] = association;
                }

                newSeedAssociations.push_back(pCandidateCluster);
                *iterI = NULL;
            }
        }

        currentSeedAssociations = newSeedAssociations;
        newSeedAssociations.clear();
        ++associationOrder;
    }
}

void lar_content::BranchGrowingAlgorithm::IdentifyClusterMerges ( const pandora::ClusterVector &  particleSeedVector, const ClusterUsageMap &  backwardUsageMap, SeedAssociationList &  seedAssociationList  ) const

protected

Identify cluster merges.

Parameters

particleSeedVector	the list of all particle seeds
backwardUsageMap	the map from cluster to particle seed associations
seedAssociationList	to receive the populated seed association list

Definition at line 73 of file BranchGrowingAlgorithm.cc.

{
    ClusterVector sortedCandidates;
    for (const auto &mapEntry : backwardUsageMap)
        sortedCandidates.push_back(mapEntry.first);
    std::sort(sortedCandidates.begin(), sortedCandidates.end(), LArClusterHelper::SortByNHits);

    for (const Cluster *const pCluster : sortedCandidates)
    {
        const ClusterAssociationMap &particleSeedUsageMap(backwardUsageMap.at(pCluster));

        if (particleSeedUsageMap.empty())
            throw StatusCodeException(STATUS_CODE_FAILURE);

        ClusterVector sortedSeeds;
        for (const auto &mapEntry : particleSeedUsageMap)
            sortedSeeds.push_back(mapEntry.first);
        std::sort(sortedSeeds.begin(), sortedSeeds.end(), LArClusterHelper::SortByNHits);

        const Cluster *pBestParticleSeed = NULL;
        AssociationType bestType(NONE);
        unsigned int bestOrder(std::numeric_limits<unsigned int>::max());

        for (const Cluster *const pParticleSeed : sortedSeeds)
        {
            const Association &association(particleSeedUsageMap.at(pParticleSeed));

            if ((association.GetType() > bestType) || ((association.GetType() == bestType) && (association.GetOrder() < bestOrder)))
            {
                // Break-out condition for single order associations
                if ((SINGLE_ORDER == association.GetType()) && (association.GetOrder() > 1))
                    continue;

                // Type is primary consideration; order breaks ties
                pBestParticleSeed = pParticleSeed;
                bestType = association.GetType();
                bestOrder = association.GetOrder();
            }
            else if ((association.GetType() == bestType) && (association.GetOrder() == bestOrder))
            {
                // Remove ambiguous cluster from algorithm
                pBestParticleSeed = NULL;
            }
        }

        if (NULL == pBestParticleSeed)
            continue;

        seedAssociationList[pBestParticleSeed].push_back(pCluster);
    }

    // Now deal with seeds that have no associations
    for (ClusterVector::const_iterator iter = particleSeedVector.begin(), iterEnd = particleSeedVector.end(); iter != iterEnd; ++iter)
    {
        const Cluster *const pParticleSeed = *iter;

        if (seedAssociationList.end() == seedAssociationList.find(pParticleSeed))
            seedAssociationList[pParticleSeed] = ClusterVector();
    }
}

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

protectedvirtual

Reimplemented in lar_content::ShowerGrowingAlgorithm.

Definition at line 137 of file BranchGrowingAlgorithm.cc.

{
    return STATUS_CODE_SUCCESS;
}

---

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

• larpandoracontent/larpandoracontent/LArTrackShowerId/BranchGrowingAlgorithm.h
• larpandoracontent/larpandoracontent/LArTrackShowerId/BranchGrowingAlgorithm.cc