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