VertexBasedPfoMopUpAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_VERTEX_BASED_PFO_MOP_UP_ALGORITHM_H
#define LAR_VERTEX_BASED_PFO_MOP_UP_ALGORITHM_H 1

#include "larpandoracontent/LArUtility/PfoMopUpBaseAlgorithm.h"

#include <unordered_map>

namespace lar_content
{

class VertexBasedPfoMopUpAlgorithm : public PfoMopUpBaseAlgorithm
{
public:
    VertexBasedPfoMopUpAlgorithm();

protected:
    class ClusterAssociation
    {
    public:
        ClusterAssociation();

        ClusterAssociation(const pandora::Cluster *const pVertexCluster, const pandora::Cluster *const pDaughterCluster, const float boundedFraction,
            const bool isConsistentDirection);

        const pandora::Cluster *GetVertexCluster() const;

        const pandora::Cluster *GetDaughterCluster() const;

        float GetBoundedFraction() const;

        bool IsConsistentDirection() const;

    private:
        const pandora::Cluster *m_pVertexCluster;           
        const pandora::Cluster *m_pDaughterCluster;         
        float                   m_boundedFraction;          
        bool                    m_isConsistentDirection;    
    };

    class PfoAssociation
    {
    public:
        PfoAssociation(const pandora::Pfo *const pVertexPfo, const pandora::Pfo *const pDaughterPfo, const ClusterAssociation &clusterAssociationU,
            const ClusterAssociation &clusterAssociationV, const ClusterAssociation &clusterAssociationW);

        const pandora::Pfo *GetVertexPfo() const;

        const pandora::Pfo *GetDaughterPfo() const;

        float GetMeanBoundedFraction() const;

        float GetMaxBoundedFraction() const;

        float GetMinBoundedFraction() const;

        unsigned int GetNConsistentDirections() const;

        const ClusterAssociation &GetClusterAssociationU() const;

        const ClusterAssociation &GetClusterAssociationV() const;

        const ClusterAssociation &GetClusterAssociationW() const;

        bool operator< (const PfoAssociation &rhs) const;

    private:
        const pandora::Pfo     *m_pVertexPfo;               
        const pandora::Pfo     *m_pDaughterPfo;             

        ClusterAssociation      m_clusterAssociationU;      
        ClusterAssociation      m_clusterAssociationV;      
        ClusterAssociation      m_clusterAssociationW;      
    };

    typedef std::vector<PfoAssociation> PfoAssociationList;

    class ConeParameters
    {
    public:
        ConeParameters(const pandora::Cluster *const pCluster, const pandora::CartesianVector &vertexPosition2D, const float coneAngleCentile,
            const float maxConeCosHalfAngle);

        float GetBoundedFraction(const pandora::Cluster *const pDaughterCluster, const float coneLengthMultiplier) const;

    private:
        pandora::CartesianVector GetDirectionEstimate() const;

        float GetSignedConeLength() const;

        float GetCosHalfAngleEstimate(const float coneAngleCentile) const;

        const pandora::Cluster     *m_pCluster;             
        pandora::CartesianVector    m_apex;                 
        pandora::CartesianVector    m_direction;            
        float                       m_coneLength;           
        float                       m_coneCosHalfAngle;     
    };

    pandora::StatusCode Run();

    virtual bool IsVertexAssociated(const pandora::CartesianVector &vertex2D, const LArPointingCluster &pointingCluster) const;

    typedef std::map<pandora::HitType, ClusterAssociation> HitTypeToAssociationMap;

    virtual PfoAssociation GetPfoAssociation(const pandora::Pfo *const pVertexPfo, const pandora::Pfo *const pDaughterPfo,
        HitTypeToAssociationMap &hitTypeToAssociationMap) const;

    void GetInputPfos(const pandora::Vertex *const pVertex, pandora::PfoList &vertexPfos, pandora::PfoList &nonVertexPfos) const;

    bool IsVertexAssociated(const pandora::Pfo *const pPfo, const pandora::Vertex *const pVertex) const;

    void GetPfoAssociations(const pandora::Vertex *const pVertex, const pandora::PfoList &vertexPfos, const pandora::PfoList &nonVertexPfos,
        PfoAssociationList &pfoAssociationList) const;

    PfoAssociation GetPfoAssociation(const pandora::Vertex *const pVertex, const pandora::Pfo *const pVertexPfo, const pandora::Pfo *const pDaughterPfo) const;

    ClusterAssociation GetClusterAssociation(const pandora::Vertex *const pVertex, const pandora::Cluster *const pVertexCluster,
        const pandora::Cluster *const pDaughterCluster) const;

    bool ProcessPfoAssociations(const PfoAssociationList &pfoAssociationList) const;

    void MergePfos(const PfoAssociation &pfoAssociation) const;

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

    typedef std::set<pandora::HitType> HitTypeSet;
    typedef std::map<pandora::HitType, const pandora::Cluster*> HitTypeToClusterMap;

    std::string             m_trackPfoListName;                 
    std::string             m_showerPfoListName;                

    float                   m_minVertexLongitudinalDistance;    
    float                   m_maxVertexTransverseDistance;      
    unsigned int            m_minVertexAssociatedHitTypes;      

    float                   m_coneAngleCentile;                 
    float                   m_maxConeCosHalfAngle;              
    float                   m_maxConeLengthMultiplier;          

    float                   m_directionTanAngle;                
    float                   m_directionApexShift;               

    float                   m_meanBoundedFractionCut;           
    float                   m_maxBoundedFractionCut;            
    float                   m_minBoundedFractionCut;            

    unsigned int            m_minConsistentDirections;          
    unsigned int            m_minConsistentDirectionsTrack;     
};

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

inline const pandora::Cluster *VertexBasedPfoMopUpAlgorithm::ClusterAssociation::GetVertexCluster() const
{
    return m_pVertexCluster;
}

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

inline const pandora::Cluster *VertexBasedPfoMopUpAlgorithm::ClusterAssociation::GetDaughterCluster() const
{
    return m_pDaughterCluster;
}

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

inline float VertexBasedPfoMopUpAlgorithm::ClusterAssociation::GetBoundedFraction() const
{
    return m_boundedFraction;
}

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

inline bool VertexBasedPfoMopUpAlgorithm::ClusterAssociation::IsConsistentDirection() const
{
    return m_isConsistentDirection;
}

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

inline const pandora::Pfo *VertexBasedPfoMopUpAlgorithm::PfoAssociation::GetVertexPfo() const
{
    return m_pVertexPfo;
}

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

inline const pandora::Pfo *VertexBasedPfoMopUpAlgorithm::PfoAssociation::GetDaughterPfo() const
{
    return m_pDaughterPfo;
}

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

inline const VertexBasedPfoMopUpAlgorithm::ClusterAssociation &VertexBasedPfoMopUpAlgorithm::PfoAssociation::GetClusterAssociationU() const
{
    return m_clusterAssociationU;
}

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

inline const VertexBasedPfoMopUpAlgorithm::ClusterAssociation &VertexBasedPfoMopUpAlgorithm::PfoAssociation::GetClusterAssociationV() const
{
    return m_clusterAssociationV;
}

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

inline const VertexBasedPfoMopUpAlgorithm::ClusterAssociation &VertexBasedPfoMopUpAlgorithm::PfoAssociation::GetClusterAssociationW() const
{
    return m_clusterAssociationW;
}

} // namespace lar_content

#endif // #ifndef LAR_VERTEX_BASED_PFO_MOP_UP_ALGORITHM_H