BranchGrowingAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_BRANCH_GROWING_ALGORITHM_H
#define LAR_BRANCH_GROWING_ALGORITHM_H 1

#include "Pandora/Algorithm.h"

#include <unordered_map>

namespace lar_content
{

class BranchGrowingAlgorithm : public pandora::Algorithm
{
protected:
    enum AssociationType
    {
        NONE = 0,
        SINGLE_ORDER = 1,
        STANDARD = 2,
        STRONG = 3
    };

    class Association
    {
    public:
        Association();

        Association(const unsigned int order, const AssociationType type);

        void SetOrder(const unsigned int order);

        void SetType(const AssociationType associationType);

        unsigned int GetOrder() const;

        AssociationType GetType() const;

    private:
        unsigned int m_order;
        AssociationType m_type;
    };

    typedef std::unordered_map<const pandora::Cluster *, Association> ClusterAssociationMap;
    typedef std::unordered_map<const pandora::Cluster *, ClusterAssociationMap> ClusterUsageMap;

    virtual AssociationType AreClustersAssociated(const pandora::Cluster *const pClusterSeed, const pandora::Cluster *const pCluster) const = 0;

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

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

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

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

//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------

inline BranchGrowingAlgorithm::Association::Association() :
    m_order(std::numeric_limits<unsigned int>::max()),
    m_type(NONE)
{
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline BranchGrowingAlgorithm::Association::Association(const unsigned int order, const AssociationType type) :
    m_order(order),
    m_type(type)
{
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline void BranchGrowingAlgorithm::Association::SetOrder(const unsigned int order)
{
    m_order = order;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline void BranchGrowingAlgorithm::Association::SetType(const AssociationType associationType)
{
    m_type = associationType;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline unsigned int BranchGrowingAlgorithm::Association::GetOrder() const
{
    return m_order;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline BranchGrowingAlgorithm::AssociationType BranchGrowingAlgorithm::Association::GetType() const
{
    return m_type;
}

} // namespace lar_content

#endif // #ifndef LAR_BRANCH_GROWING_ALGORITHM_H