lar_content::ShowerGrowingAlgorithm Class Reference

ShowerGrowingAlgorithm class. More...

#include "ShowerGrowingAlgorithm.h"

Inheritance diagram for lar_content::ShowerGrowingAlgorithm:

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

Protected Types
typedef std::unordered_map< const pandora::Cluster *, LArVertexHelper::ClusterDirection >	ClusterDirectionMap
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
bool	IsVertexAssociated (const LArPointingCluster &pointingCluster, const pandora::CartesianVector &vertexPosition2D) const
	Whether a pointing cluster is assciated with a provided 2D vertex projection. 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...

Static Protected Member Functions
static bool	SortClusters (const pandora::Cluster *const pLhs, const pandora::Cluster *const pRhs)
	Sorting for clusters to determine order in which seeds are considered. More...

Protected Attributes
ClusterDirectionMap	m_clusterDirectionMap
	The cluster direction map. More...

Private Member Functions
pandora::StatusCode	Run ()
void	SimpleModeShowerGrowing (const pandora::ClusterList *const pClusterList, const std::string &clusterListName) const
	Simple single-pass shower growing mode. More...
bool	GetNextSeedCandidate (const pandora::ClusterList *const pClusterList, const pandora::ClusterSet &usedClusters, const pandora::Cluster *&pSeedCluster) const
	Get the next seed candidate, using a list of available candidates and a list of those already used. More...
void	GetAllVertexSeedCandidates (const pandora::ClusterList *const pClusterList, const pandora::Vertex *const pVertex, pandora::ClusterVector &seedClusters) const
	Get all seed candidates associated with a provided vertex. More...
void	GetSeedAssociationList (const pandora::ClusterVector &particleSeedVector, const pandora::ClusterList *const pClusterList, SeedAssociationList &seedAssociationList) const
	Get the seed association list for a given vector of particle seed candidates. More...
void	ProcessSeedAssociationDetails (const SeedAssociationList &seedAssociationList, const std::string &clusterListName, pandora::ClusterSet &usedClusters) const
	Process the details stored in a specified seed association list. More...
void	ProcessBranchClusters (const pandora::Cluster *const pParentCluster, const pandora::ClusterVector &branchClusters, const std::string &listName) const
	Process the list of branch clusters, merging with specified parent cluster, dealing with any existing pfos as required. More...
AssociationType	AreClustersAssociated (const pandora::Cluster *const pClusterSeed, const pandora::Cluster *const pCluster) const
	Determine whether two clusters are associated. More...
float	GetFigureOfMerit (const SeedAssociationList &seedAssociationList) const
	Get a figure of merit representing the consistency of the provided seed associated list. More...
unsigned int	GetNVertexConnections (const pandora::CartesianVector &vertexPosition2D, const LArPointingClusterList &pointingClusterList) const
	Get the number of clusters associated with the vertex. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Private Attributes
pandora::StringVector	m_inputClusterListNames
	The names of the input cluster lists. More...
unsigned int	m_minCaloHitsPerCluster
	The minimum number of calo hits per (seed or branch) cluster. More...
float	m_nearbyClusterDistance
	The nearby cluster distance, used for determining cluster associations. More...
float	m_remoteClusterDistance
	The remote cluster distance, used for determining cluster associations. More...
float	m_directionTanAngle
	Direction determination, look for vertex inside triangle with apex shifted along the cluster length. More...
float	m_directionApexShift
	Direction determination, look for vertex inside triangle with apex shifted along the cluster length. More...
float	m_minVertexLongitudinalDistance
	Vertex association check: min longitudinal distance cut. More...
float	m_maxVertexLongitudinalDistance
	Vertex association check: max longitudinal distance cut. More...
float	m_maxVertexTransverseDistance
	Vertex association check: max transverse distance cut. More...
float	m_vertexAngularAllowance
	Vertex association check: pointing angular allowance in degrees. More...

Detailed Description

ShowerGrowingAlgorithm class.

Definition at line 27 of file ShowerGrowingAlgorithm.h.

Member Typedef Documentation

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

protectedinherited

Definition at line 87 of file BranchGrowingAlgorithm.h.

typedef std::unordered_map<const pandora::Cluster*, LArVertexHelper::ClusterDirection> lar_content::ShowerGrowingAlgorithm::ClusterDirectionMap

protected

Definition at line 54 of file ShowerGrowingAlgorithm.h.

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

protectedinherited

Definition at line 88 of file BranchGrowingAlgorithm.h.

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

protectedinherited

Definition at line 111 of file BranchGrowingAlgorithm.h.

Member Enumeration Documentation

enum lar_content::BranchGrowingAlgorithm::AssociationType

protectedinherited

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
    };

Constructor & Destructor Documentation

lar_content::ShowerGrowingAlgorithm::ShowerGrowingAlgorithm

(

)

Default constructor.

Definition at line 25 of file ShowerGrowingAlgorithm.cc.

                                               :
    m_minCaloHitsPerCluster(5),
    m_nearbyClusterDistance(2.5f),
    m_remoteClusterDistance(10.f),
    m_directionTanAngle(1.732f),
    m_directionApexShift(0.333f),
    m_minVertexLongitudinalDistance(-2.5f),
    m_maxVertexLongitudinalDistance(20.f),
    m_maxVertexTransverseDistance(1.5f),
    m_vertexAngularAllowance(3.f)
{
}

Member Function Documentation

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

privatevirtual

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

Implements lar_content::BranchGrowingAlgorithm.

Definition at line 272 of file ShowerGrowingAlgorithm.cc.

References lar_content::LArVertexHelper::DIRECTION_BACKWARD_IN_Z, lar_content::LArVertexHelper::DIRECTION_FORWARD_IN_Z, lar_content::LArVertexHelper::DIRECTION_UNKNOWN, lar_content::LArClusterHelper::GetClosestDistance(), lar_content::LArVertexHelper::GetClusterDirectionInZ(), m_clusterDirectionMap, m_directionApexShift, m_directionTanAngle, m_nearbyClusterDistance, m_remoteClusterDistance, lar_content::BranchGrowingAlgorithm::NONE, lar_content::BranchGrowingAlgorithm::SINGLE_ORDER, lar_content::BranchGrowingAlgorithm::STANDARD, and lar_content::BranchGrowingAlgorithm::STRONG.

{
    const VertexList *pVertexList(nullptr);
    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pVertexList));
    const Vertex *const pVertex(((pVertexList->size() == 1) && (VERTEX_3D == (*(pVertexList->begin()))->GetVertexType())) ? *(pVertexList->begin()) : nullptr);

    // Direction of seed cluster (cache for efficiency)
    ClusterDirectionMap::const_iterator seedIter = m_clusterDirectionMap.find(pClusterSeed);

    if (m_clusterDirectionMap.end() == seedIter)
    {
        const LArVertexHelper::ClusterDirection direction((nullptr == pVertex) ? LArVertexHelper::DIRECTION_UNKNOWN :
            LArVertexHelper::GetClusterDirectionInZ(this->GetPandora(), pVertex, pClusterSeed, m_directionTanAngle, m_directionApexShift));
        seedIter = m_clusterDirectionMap.insert(ClusterDirectionMap::value_type(pClusterSeed, direction)).first;
    }

    const LArVertexHelper::ClusterDirection seedDirection(seedIter->second);
    const bool checkSeedForward(seedDirection != LArVertexHelper::DIRECTION_BACKWARD_IN_Z);
    const bool checkSeedBackward(seedDirection != LArVertexHelper::DIRECTION_FORWARD_IN_Z);

    // Direction of candidate cluster (cache for efficiency)
    ClusterDirectionMap::const_iterator candIter = m_clusterDirectionMap.find(pCluster);

    if (m_clusterDirectionMap.end() == candIter)
    {
        const LArVertexHelper::ClusterDirection direction((nullptr == pVertex) ? LArVertexHelper::DIRECTION_UNKNOWN :
            LArVertexHelper::GetClusterDirectionInZ(this->GetPandora(), pVertex, pCluster, m_directionTanAngle, m_directionApexShift));
        candIter = m_clusterDirectionMap.insert(ClusterDirectionMap::value_type(pCluster, direction)).first;
    }

    const LArVertexHelper::ClusterDirection candidateDirection(candIter->second);
    const bool checkCandidateForward(candidateDirection != LArVertexHelper::DIRECTION_BACKWARD_IN_Z);
    const bool checkCandidateBackward(candidateDirection != LArVertexHelper::DIRECTION_FORWARD_IN_Z);

    // Calculate distances of association
    const float sOuter(LArClusterHelper::GetClosestDistance(pClusterSeed->GetCentroid(pClusterSeed->GetOuterPseudoLayer()), pCluster));
    const float cOuter(LArClusterHelper::GetClosestDistance(pCluster->GetCentroid(pCluster->GetOuterPseudoLayer()), pClusterSeed));
    const float sInner(LArClusterHelper::GetClosestDistance(pClusterSeed->GetCentroid(pClusterSeed->GetInnerPseudoLayer()), pCluster));
    const float cInner(LArClusterHelper::GetClosestDistance(pCluster->GetCentroid(pCluster->GetInnerPseudoLayer()), pClusterSeed));

    // Association check 1(a), look for enclosed clusters
    if ((cOuter < m_nearbyClusterDistance && cInner < m_nearbyClusterDistance) &&
        (!checkSeedForward || (sInner > m_nearbyClusterDistance)) &&
        (!checkSeedBackward || (sOuter > m_nearbyClusterDistance)))
    {
        return STRONG;
    }

    // Association check 1(b), look for overlapping clusters
    if ((checkSeedForward == checkCandidateForward) && (checkSeedBackward == checkCandidateBackward))
    {
        if ((cInner < m_nearbyClusterDistance && sOuter < m_nearbyClusterDistance) &&
            (!checkSeedForward || (sInner > m_nearbyClusterDistance)) &&
            (!checkSeedBackward || (cOuter > m_nearbyClusterDistance)))
        {
            return STRONG;
        }

        if ((cOuter < m_nearbyClusterDistance && sInner < m_nearbyClusterDistance) &&
            (!checkSeedBackward || (sOuter > m_nearbyClusterDistance)) &&
            (!checkSeedForward || (cInner > m_nearbyClusterDistance)))
        {
            return STRONG;
        }
    }

    // Association check 2, look for branching clusters
    if ((!checkSeedForward || (sInner > m_remoteClusterDistance)) &&
        (!checkSeedBackward || (sOuter > m_remoteClusterDistance)) &&
        ((checkCandidateForward && (cInner < m_nearbyClusterDistance)) || (checkCandidateBackward && (cOuter < m_nearbyClusterDistance))))
    {
        return STANDARD;
    }

    // Association check 3, look any distance below threshold
    if ((sOuter < m_nearbyClusterDistance) || (cOuter < m_nearbyClusterDistance) || (sInner < m_nearbyClusterDistance) || (cInner < m_nearbyClusterDistance))
        return SINGLE_ORDER;

    return NONE;
}

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

protectedinherited

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.

References lar_content::BranchGrowingAlgorithm::Association::GetType(), min, and lar_content::BranchGrowingAlgorithm::Association::SetType().

Referenced by GetSeedAssociationList().

{
    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::ShowerGrowingAlgorithm::GetAllVertexSeedCandidates ( const pandora::ClusterList *const  pClusterList, const pandora::Vertex *const  pVertex, pandora::ClusterVector &  seedClusters  ) const

private

Get all seed candidates associated with a provided vertex.

Parameters

pClusterList	the list of available seed candidates
pVertex	the address of the vertex
seedClusters	to receive the list of vertex seed candidates

Definition at line 161 of file ShowerGrowingAlgorithm.cc.

References lar_content::LArClusterHelper::GetClusterHitType(), IsVertexAssociated(), m_minCaloHitsPerCluster, lar_content::LArGeometryHelper::ProjectPosition(), and SortClusters().

Referenced by SimpleModeShowerGrowing().

{
    ClusterVector clusterVector;
    clusterVector.insert(clusterVector.end(), pClusterList->begin(), pClusterList->end());

    if (clusterVector.empty())
        return;

    const HitType hitType(LArClusterHelper::GetClusterHitType(clusterVector.at(0)));
    const CartesianVector vertexPosition2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType));

    for (const Cluster *const pCluster : clusterVector)
    {
        if (!pCluster->IsAvailable())
            continue;

        if (MU_MINUS == std::abs(pCluster->GetParticleId()))
            continue;

        if (pCluster->GetNCaloHits() < m_minCaloHitsPerCluster)
            continue;

        try
        {
            if (this->IsVertexAssociated(LArPointingCluster(pCluster), vertexPosition2D))
                seedClusters.push_back(pCluster);
        }
        catch (StatusCodeException &)
        {
        }
    }

    std::sort(seedClusters.begin(), seedClusters.end(), ShowerGrowingAlgorithm::SortClusters);
}

float lar_content::ShowerGrowingAlgorithm::GetFigureOfMerit ( const SeedAssociationList &  seedAssociationList ) const

private

Get a figure of merit representing the consistency of the provided seed associated list.

Parameters

seedAssociationList

the seed association list

Returns

the figure of merit

Definition at line 355 of file ShowerGrowingAlgorithm.cc.

References lar_content::LArClusterHelper::GetClusterHitType(), GetNVertexConnections(), lar_content::LArGeometryHelper::ProjectPosition(), and lar_content::LArClusterHelper::SortByNHits().

{
    const VertexList *pVertexList(nullptr);
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pVertexList));
    const Vertex *const pVertex(((pVertexList->size() == 1) && (VERTEX_3D == (*(pVertexList->begin()))->GetVertexType())) ? *(pVertexList->begin()) : nullptr);

    // ATTN Consistently returning same value will accept all candidate cluster merges
    if (!pVertex)
        return -1.f;

    unsigned int nVertexAssociatedSeeds(0), nVertexAssociatedNonSeeds(0);

    ClusterList clusterList;
    for (const auto &mapEntry : seedAssociationList) clusterList.push_back(mapEntry.first);
    clusterList.sort(LArClusterHelper::SortByNHits);

    for (const Cluster *const pSeedCluster : clusterList)
    {
        const ClusterVector &associatedClusters(seedAssociationList.at(pSeedCluster));
        const HitType hitType(LArClusterHelper::GetClusterHitType(pSeedCluster));
        const CartesianVector vertex2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType));

        LArPointingClusterList pointingClusterSeedList;
        try {pointingClusterSeedList.push_back(LArPointingCluster(pSeedCluster));} catch (StatusCodeException &) {}

        LArPointingClusterList pointingClusterNonSeedList;
        for (const Cluster *const pAssociatedCluster : associatedClusters)
        {
            try {pointingClusterNonSeedList.push_back(LArPointingCluster(pAssociatedCluster));} catch (StatusCodeException &) {}
        }

        nVertexAssociatedSeeds += this->GetNVertexConnections(vertex2D, pointingClusterSeedList);
        nVertexAssociatedNonSeeds += this->GetNVertexConnections(vertex2D, pointingClusterNonSeedList);
    }

    const float figureOfMerit(static_cast<float>(nVertexAssociatedSeeds) - static_cast<float>(nVertexAssociatedNonSeeds));
    return figureOfMerit;
}

bool lar_content::ShowerGrowingAlgorithm::GetNextSeedCandidate ( const pandora::ClusterList *const  pClusterList, const pandora::ClusterSet &  usedClusters, const pandora::Cluster *&  pSeedCluster  ) const

private

Get the next seed candidate, using a list of available candidates and a list of those already used.

Parameters

pClusterList	the list of available seed candidates
usedClusters	the list of candidates already considered
pSeedCluster	to receive the address of the next seed candidate

Returns

whether a seed candidate has been found

Definition at line 129 of file ShowerGrowingAlgorithm.cc.

References m_minCaloHitsPerCluster, and SortClusters().

Referenced by SimpleModeShowerGrowing().

{
    pSeedCluster = nullptr;

    ClusterVector clusterVector;
    clusterVector.insert(clusterVector.end(), pClusterList->begin(), pClusterList->end());
    std::sort(clusterVector.begin(), clusterVector.end(), ShowerGrowingAlgorithm::SortClusters);

    for (const Cluster *const pCluster : clusterVector)
    {
        if (!pCluster->IsAvailable())
            continue;

        if (MU_MINUS == std::abs(pCluster->GetParticleId()))
            continue;

        if (pCluster->GetNCaloHits() < m_minCaloHitsPerCluster)
            continue;

        if (usedClusters.count(pCluster))
            continue;

        pSeedCluster = pCluster;
        return true;
    }

    return false;
}

unsigned int lar_content::ShowerGrowingAlgorithm::GetNVertexConnections ( const pandora::CartesianVector &  vertexPosition2D, const LArPointingClusterList &  pointingClusterList  ) const

private

Get the number of clusters associated with the vertex.

Parameters

vertexPosition2D	the projected vertex position
pointingClusterList	the list of relevant pointing clusters

Returns

the number of clusters associated with the vertex

Definition at line 396 of file ShowerGrowingAlgorithm.cc.

References IsVertexAssociated().

Referenced by GetFigureOfMerit().

{
    unsigned int nConnections(0);

    for (LArPointingClusterList::const_iterator cIter = pointingClusterList.begin(), cIterEnd = pointingClusterList.end(); cIter != cIterEnd; ++cIter)
    {
        if (this->IsVertexAssociated(*cIter, vertexPosition2D))
            ++nConnections;
    }

    return nConnections;
}

void lar_content::ShowerGrowingAlgorithm::GetSeedAssociationList ( const pandora::ClusterVector &  particleSeedVector, const pandora::ClusterList *const  pClusterList, SeedAssociationList &  seedAssociationList  ) const

private

Get the seed association list for a given vector of particle seed candidates.

Parameters

particleSeedVector	the particle seed vector
pClusterList	the address of the input cluster list
seedAssociationList	to receive the populated seed association list

Definition at line 199 of file ShowerGrowingAlgorithm.cc.

References lar_content::BranchGrowingAlgorithm::FindAssociatedClusters(), lar_content::BranchGrowingAlgorithm::IdentifyClusterMerges(), m_minCaloHitsPerCluster, and SortClusters().

Referenced by SimpleModeShowerGrowing().

{
    if (particleSeedVector.empty())
        return;

    ClusterVector candidateClusters;
    const ClusterList clusterList(*pClusterList);

    for (const Cluster *const pCandidateCluster : clusterList)
    {
        if (!pCandidateCluster->IsAvailable())
            continue;

        if (MU_MINUS == std::abs(pCandidateCluster->GetParticleId()))
            continue;

        if (pCandidateCluster->GetNCaloHits() < m_minCaloHitsPerCluster)
            continue;

        if (particleSeedVector.end() == std::find(particleSeedVector.begin(), particleSeedVector.end(), pCandidateCluster))
            candidateClusters.push_back(pCandidateCluster);
    }

    std::sort(candidateClusters.begin(), candidateClusters.end(), ShowerGrowingAlgorithm::SortClusters);
    ClusterUsageMap forwardUsageMap, backwardUsageMap;

    for (const Cluster *const pSeedCluster : particleSeedVector)
    {
        this->FindAssociatedClusters(pSeedCluster, candidateClusters, forwardUsageMap, backwardUsageMap);
    }

    this->IdentifyClusterMerges(particleSeedVector, backwardUsageMap, seedAssociationList);
}

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

protectedinherited

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.

References lar_content::BranchGrowingAlgorithm::Association::GetType(), and max.

Referenced by GetSeedAssociationList().

{
    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();
    }
}

bool lar_content::ShowerGrowingAlgorithm::IsVertexAssociated ( const LArPointingCluster &  pointingCluster, const pandora::CartesianVector &  vertexPosition2D  ) const

protected

Whether a pointing cluster is assciated with a provided 2D vertex projection.

Parameters

pointingCluster	the pointing cluster
vertexPosition2D	the projected vertex position

Returns

boolean

Definition at line 40 of file ShowerGrowingAlgorithm.cc.

References lar_content::LArPointingCluster::GetInnerVertex(), lar_content::LArPointingCluster::GetOuterVertex(), lar_content::LArPointingClusterHelper::IsEmission(), lar_content::LArPointingClusterHelper::IsNode(), m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_minVertexLongitudinalDistance, and m_vertexAngularAllowance.

Referenced by GetAllVertexSeedCandidates(), and GetNVertexConnections().

{
    return (LArPointingClusterHelper::IsNode(vertexPosition2D, pointingCluster.GetInnerVertex(), m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
        LArPointingClusterHelper::IsNode(vertexPosition2D, pointingCluster.GetOuterVertex(), m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
        LArPointingClusterHelper::IsEmission(vertexPosition2D, pointingCluster.GetInnerVertex(), m_minVertexLongitudinalDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance) ||
        LArPointingClusterHelper::IsEmission(vertexPosition2D, pointingCluster.GetOuterVertex(), m_minVertexLongitudinalDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance));
}

void lar_content::ShowerGrowingAlgorithm::ProcessBranchClusters ( const pandora::Cluster *const  pParentCluster, const pandora::ClusterVector &  branchClusters, const std::string &  listName  ) const

private

Process the list of branch clusters, merging with specified parent cluster, dealing with any existing pfos as required.

Parameters

pParentCluster	the address of the parent cluster
branchClusters	the list of branch clusters for the specified seed cluster
listName	the cluster list name
pfoList	the input pfo list

Definition at line 255 of file ShowerGrowingAlgorithm.cc.

References m_clusterDirectionMap.

Referenced by ProcessSeedAssociationDetails().

{
    m_clusterDirectionMap.erase(pParentCluster);

    for (const Cluster *const pBranchCluster : branchClusters)
    {
        if (pBranchCluster->IsAvailable())
        {
            PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*this, pParentCluster, pBranchCluster, listName, listName));
        }

        m_clusterDirectionMap.erase(pBranchCluster);
    }
}

void lar_content::ShowerGrowingAlgorithm::ProcessSeedAssociationDetails ( const SeedAssociationList &  seedAssociationList, const std::string &  clusterListName, pandora::ClusterSet &  usedClusters  ) const

private

Process the details stored in a specified seed association list.

Parameters

seedAssociationList	the seed association list
clusterListName	the cluster list name
pfoList	the pfo list
usedClusters	the list of candidates already considered

Definition at line 236 of file ShowerGrowingAlgorithm.cc.

References ProcessBranchClusters(), and lar_content::LArClusterHelper::SortByNHits().

Referenced by SimpleModeShowerGrowing().

{
    ClusterList clusterList;
    for (const auto &mapEntry : seedAssociationList) clusterList.push_back(mapEntry.first);
    clusterList.sort(LArClusterHelper::SortByNHits);

    for (const Cluster *const pParentCluster : clusterList)
    {
        const ClusterVector &branchClusters(seedAssociationList.at(pParentCluster));
        this->ProcessBranchClusters(pParentCluster, branchClusters, clusterListName);

        usedClusters.insert(pParentCluster);
        usedClusters.insert(branchClusters.begin(), branchClusters.end());
    }
}

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

privatevirtual

Reimplemented from lar_content::BranchGrowingAlgorithm.

Definition at line 411 of file ShowerGrowingAlgorithm.cc.

References m_directionApexShift, m_directionTanAngle, m_inputClusterListNames, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_minCaloHitsPerCluster, m_minVertexLongitudinalDistance, m_nearbyClusterDistance, m_remoteClusterDistance, m_vertexAngularAllowance, and lar_content::BranchGrowingAlgorithm::ReadSettings().

{
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "InputClusterListNames", m_inputClusterListNames));

    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,
        "NearbyClusterDistance", m_nearbyClusterDistance));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "RemoteClusterDistance", m_remoteClusterDistance));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "DirectionTanAngle", m_directionTanAngle));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "DirectionApexShift", m_directionApexShift));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "MinVertexLongitudinalDistance", m_minVertexLongitudinalDistance));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "MaxVertexLongitudinalDistance", m_maxVertexLongitudinalDistance));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "MaxVertexTransverseDistance", m_maxVertexTransverseDistance));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "VertexAngularAllowance", m_vertexAngularAllowance));

    return BranchGrowingAlgorithm::ReadSettings(xmlHandle);
}

StatusCode lar_content::ShowerGrowingAlgorithm::Run ( )

private

Definition at line 65 of file ShowerGrowingAlgorithm.cc.

References m_clusterDirectionMap, m_inputClusterListNames, and SimpleModeShowerGrowing().

{
    for (const std::string &clusterListName : m_inputClusterListNames)
    {
        try
        {
            const ClusterList *pClusterList = nullptr;
            PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, clusterListName, pClusterList));

            if (!pClusterList || pClusterList->empty())
            {
                if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
                    std::cout << "ShowerGrowingAlgorithm: unable to find cluster list " << clusterListName << std::endl;

                continue;
            }

            this->SimpleModeShowerGrowing(pClusterList, clusterListName);
            m_clusterDirectionMap.clear();
        }
        catch (StatusCodeException &statusCodeException)
        {
            m_clusterDirectionMap.clear();
            throw statusCodeException;
        }
    }

    return STATUS_CODE_SUCCESS;
}

void lar_content::ShowerGrowingAlgorithm::SimpleModeShowerGrowing ( const pandora::ClusterList *const  pClusterList, const std::string &  clusterListName  ) const

private

Simple single-pass shower growing mode.

Parameters

pClusterList	the list of clusters
clusterListName	the cluster list name

Definition at line 97 of file ShowerGrowingAlgorithm.cc.

References GetAllVertexSeedCandidates(), GetNextSeedCandidate(), GetSeedAssociationList(), and ProcessSeedAssociationDetails().

Referenced by Run().

{
    const VertexList *pVertexList(nullptr);
    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pVertexList));
    const Vertex *const pVertex(((pVertexList->size() == 1) && (VERTEX_3D == (*(pVertexList->begin()))->GetVertexType())) ? *(pVertexList->begin()) : nullptr);

    ClusterSet usedClusters;

    // Pick up all showers starting at vertex
    if (pVertex)
    {
        ClusterVector seedClusters;
        this->GetAllVertexSeedCandidates(pClusterList, pVertex, seedClusters);

        SeedAssociationList vertexSeedAssociationList;
        this->GetSeedAssociationList(seedClusters, pClusterList, vertexSeedAssociationList);
        this->ProcessSeedAssociationDetails(vertexSeedAssociationList, clusterListName, usedClusters);
    }

    // Non-vertex showers
    const Cluster *pSeedCluster(nullptr);

    while (this->GetNextSeedCandidate(pClusterList, usedClusters, pSeedCluster))
    {
        SeedAssociationList seedAssociationList;
        this->GetSeedAssociationList(ClusterVector(1, pSeedCluster), pClusterList, seedAssociationList);
        this->ProcessSeedAssociationDetails(seedAssociationList, clusterListName, usedClusters);
    }
}

bool lar_content::ShowerGrowingAlgorithm::SortClusters ( const pandora::Cluster *const  pLhs, const pandora::Cluster *const  pRhs  )

staticprotected

Sorting for clusters to determine order in which seeds are considered.

Parameters

pLhs	address of first cluster
pRhs	address of second cluster

Definition at line 50 of file ShowerGrowingAlgorithm.cc.

References f, and lar_content::LArClusterHelper::GetExtremalCoordinates().

Referenced by GetAllVertexSeedCandidates(), GetNextSeedCandidate(), and GetSeedAssociationList().

{
    CartesianVector innerCoordinateLhs(0.f, 0.f, 0.f), outerCoordinateLhs(0.f, 0.f, 0.f);
    LArClusterHelper::GetExtremalCoordinates(pLhs, innerCoordinateLhs, outerCoordinateLhs);
    const float dLhs2((outerCoordinateLhs - innerCoordinateLhs).GetMagnitudeSquared());

    CartesianVector innerCoordinateRhs(0.f, 0.f, 0.f), outerCoordinateRhs(0.f, 0.f, 0.f);
    LArClusterHelper::GetExtremalCoordinates(pRhs, innerCoordinateRhs, outerCoordinateRhs);
    const float dRhs2((outerCoordinateRhs - innerCoordinateRhs).GetMagnitudeSquared());

    return (dLhs2 > dRhs2);
}

Member Data Documentation

ClusterDirectionMap lar_content::ShowerGrowingAlgorithm::m_clusterDirectionMap

mutableprotected

The cluster direction map.

Definition at line 55 of file ShowerGrowingAlgorithm.h.

Referenced by AreClustersAssociated(), ProcessBranchClusters(), and Run().

float lar_content::ShowerGrowingAlgorithm::m_directionApexShift

private

Direction determination, look for vertex inside triangle with apex shifted along the cluster length.

Definition at line 152 of file ShowerGrowingAlgorithm.h.

Referenced by AreClustersAssociated(), and ReadSettings().

float lar_content::ShowerGrowingAlgorithm::m_directionTanAngle

private

Direction determination, look for vertex inside triangle with apex shifted along the cluster length.

Definition at line 151 of file ShowerGrowingAlgorithm.h.

Referenced by AreClustersAssociated(), and ReadSettings().

pandora::StringVector lar_content::ShowerGrowingAlgorithm::m_inputClusterListNames

private

The names of the input cluster lists.

Definition at line 145 of file ShowerGrowingAlgorithm.h.

Referenced by ReadSettings(), and Run().

float lar_content::ShowerGrowingAlgorithm::m_maxVertexLongitudinalDistance

private

Vertex association check: max longitudinal distance cut.

Definition at line 155 of file ShowerGrowingAlgorithm.h.

Referenced by IsVertexAssociated(), and ReadSettings().

float lar_content::ShowerGrowingAlgorithm::m_maxVertexTransverseDistance

private

Vertex association check: max transverse distance cut.

Definition at line 156 of file ShowerGrowingAlgorithm.h.

Referenced by IsVertexAssociated(), and ReadSettings().

unsigned int lar_content::ShowerGrowingAlgorithm::m_minCaloHitsPerCluster

private

The minimum number of calo hits per (seed or branch) cluster.

Definition at line 147 of file ShowerGrowingAlgorithm.h.

Referenced by GetAllVertexSeedCandidates(), GetNextSeedCandidate(), GetSeedAssociationList(), and ReadSettings().

float lar_content::ShowerGrowingAlgorithm::m_minVertexLongitudinalDistance

private

Vertex association check: min longitudinal distance cut.

Definition at line 154 of file ShowerGrowingAlgorithm.h.

Referenced by IsVertexAssociated(), and ReadSettings().

float lar_content::ShowerGrowingAlgorithm::m_nearbyClusterDistance

private

The nearby cluster distance, used for determining cluster associations.

Definition at line 148 of file ShowerGrowingAlgorithm.h.

Referenced by AreClustersAssociated(), and ReadSettings().

float lar_content::ShowerGrowingAlgorithm::m_remoteClusterDistance

private

The remote cluster distance, used for determining cluster associations.

Definition at line 149 of file ShowerGrowingAlgorithm.h.

Referenced by AreClustersAssociated(), and ReadSettings().

float lar_content::ShowerGrowingAlgorithm::m_vertexAngularAllowance

private

Vertex association check: pointing angular allowance in degrees.

Definition at line 157 of file ShowerGrowingAlgorithm.h.

Referenced by IsVertexAssociated(), and ReadSettings().

---

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

• /cvmfs/larsoft.opensciencegrid.org/products/larpandoracontent/v03_14_03/source/larpandoracontent/LArTrackShowerId/ShowerGrowingAlgorithm.h
• /cvmfs/larsoft.opensciencegrid.org/products/larpandoracontent/v03_14_03/source/larpandoracontent/LArTrackShowerId/ShowerGrowingAlgorithm.cc