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