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