SlidingConeClusterMopUpAlgorithm.h

Go to the documentation of this file.

 
#ifndef LAR_SLIDING_CONE_CLUSTER_MOP_UP_ALGORITHM_H
#define LAR_SLIDING_CONE_CLUSTER_MOP_UP_ALGORITHM_H 1
 
#include "larpandoracontent/LArUtility/PfoMopUpBaseAlgorithm.h"
 
#include <unordered_map>
 
namespace lar_content
{
 
class SlidingConeClusterMopUpAlgorithm : public PfoMopUpBaseAlgorithm
{
public:
    SlidingConeClusterMopUpAlgorithm();
 
private:
    class ClusterMerge
    {
    public:
        ClusterMerge(const pandora::Cluster *const pParentCluster, const float boundedFraction, const float meanRT);
 
        const pandora::Cluster *GetParentCluster() const;
 
        float GetBoundedFraction() const;
 
        float GetMeanRT() const;
 
        bool operator<(const ClusterMerge &rhs) const;
 
    private:
        const pandora::Cluster *m_pParentCluster; 
        float m_boundedFraction;                  
        float m_meanRT;                           
    };
 
    typedef std::vector<ClusterMerge> ClusterMergeList;
 
    pandora::StatusCode Run();
 
    void GetInteractionVertex(const pandora::Vertex *&pVertex) const;
 
    typedef std::unordered_map<const pandora::Cluster *, const pandora::ParticleFlowObject *> ClusterToPfoMap;
 
    void GetThreeDClusters(pandora::ClusterVector &clusters3D, ClusterToPfoMap &clusterToPfoMap) const;
 
    void GetAvailableTwoDClusters(pandora::ClusterVector &availableClusters2D) const;
 
    typedef std::unordered_map<const pandora::Cluster *, ClusterMergeList> ClusterMergeMap;
 
    void GetClusterMergeMap(const pandora::Vertex *const pVertex, const pandora::ClusterVector &clusters3D,
        const pandora::ClusterVector &availableClusters2D, ClusterMergeMap &clusterMergeMap) const;
 
    void MakeClusterMerges(const ClusterToPfoMap &clusterToPfoMap, const ClusterMergeMap &clusterMergeMap) const;
 
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
 
    pandora::StringVector m_inputPfoListNames; 
    bool m_useVertex;                          
    unsigned int m_maxIterations;              
    unsigned int m_maxHitsToConsider3DTrack;   
    unsigned int m_minHitsToConsider3DShower;  
    unsigned int m_maxHitsToConsider2DCluster; 
    unsigned int m_halfWindowLayers;           
    unsigned int m_nConeFitLayers;             
    unsigned int m_nConeFits;                  
    float m_coneLengthMultiplier;              
    float m_maxConeLength;                     
    float m_coneTanHalfAngle;                  
    float m_coneBoundedFraction;               
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline SlidingConeClusterMopUpAlgorithm::ClusterMerge::ClusterMerge(
    const pandora::Cluster *const pParentCluster, const float boundedFraction, const float meanRT) :
    m_pParentCluster(pParentCluster),
    m_boundedFraction(boundedFraction),
    m_meanRT(meanRT)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::Cluster *SlidingConeClusterMopUpAlgorithm::ClusterMerge::GetParentCluster() const
{
    return m_pParentCluster;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float SlidingConeClusterMopUpAlgorithm::ClusterMerge::GetBoundedFraction() const
{
    return m_boundedFraction;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float SlidingConeClusterMopUpAlgorithm::ClusterMerge::GetMeanRT() const
{
    return m_meanRT;
}
 
} // namespace lar_content
 
#endif // #ifndef LAR_SLIDING_CONE_CLUSTER_MOP_UP_ALGORITHM_H