VertexSelectionBaseAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_VERTEX_SELECTION_BASE_ALGORITHM_H
#define LAR_VERTEX_SELECTION_BASE_ALGORITHM_H 1

#include "Pandora/Algorithm.h"

#include "larpandoracontent/LArHelpers/LArMvaHelper.h"

#include "larpandoracontent/LArObjects/LArSupportVectorMachine.h"
#include "larpandoracontent/LArObjects/LArTwoDSlidingFitResult.h"

namespace lar_content
{

template<typename, unsigned int> class KDTreeLinkerAlgo;
template<typename, unsigned int> class KDTreeNodeInfoT;

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

class VertexSelectionBaseAlgorithm : public pandora::Algorithm
{
public:
    VertexSelectionBaseAlgorithm();

    class VertexScore
    {
    public:
        VertexScore(const pandora::Vertex *const pVertex, const float score);

        const pandora::Vertex *GetVertex() const;

        float GetScore() const;

        bool operator< (const VertexScore &rhs) const;

    private:
        const pandora::Vertex  *m_pVertex;          
        float                   m_score;            
    };

    typedef std::vector<VertexScore> VertexScoreList;

    class BeamConstants
    {
    public:
        float GetMinZCoordinate() const;

        float GetDecayConstant() const;

        void SetConstants(const float minZCoordinate, const float decayConstant);

    private:
        pandora::InputFloat     m_minZCoordinate;   
        pandora::InputFloat     m_decayConstant;    
    };

    class SlidingFitData
    {
    public:
        SlidingFitData(const pandora::Cluster *const pCluster, const int slidingFitWindow, const float slidingFitPitch);

        const pandora::CartesianVector &GetMinLayerDirection() const;

        const pandora::CartesianVector &GetMaxLayerDirection() const;

        const pandora::CartesianVector &GetMinLayerPosition() const;

        const pandora::CartesianVector &GetMaxLayerPosition() const;

        const pandora::Cluster *GetCluster() const;

    private:
        pandora::CartesianVector    m_minLayerDirection;    
        pandora::CartesianVector    m_maxLayerDirection;    
        pandora::CartesianVector    m_minLayerPosition;     
        pandora::CartesianVector    m_maxLayerPosition;     
        const pandora::Cluster     *m_pCluster;             
    };

    typedef std::vector<SlidingFitData> SlidingFitDataList;

    class ShowerCluster
    {
    public:
        ShowerCluster(const pandora::ClusterList &clusterList, const int slidingFitWindow, const float slidingFitPitch);

        const pandora::ClusterList &GetClusters() const;

        const TwoDSlidingFitResult &GetFit() const;

        pandora::CartesianPointVector GetClusterListCoordinateVector(const pandora::ClusterList &clusterList) const;

    private:
        pandora::ClusterList             m_clusterList;             
        pandora::CartesianPointVector    m_coordinateVector;        
        TwoDSlidingFitResult             m_twoDSlidingFitResult;    
    };

    typedef std::vector<ShowerCluster> ShowerClusterList;

    typedef KDTreeNodeInfoT<const pandora::CaloHit*, 2> HitKDNode2D;
    typedef std::vector<HitKDNode2D> HitKDNode2DList;
    typedef KDTreeLinkerAlgo<const pandora::CaloHit*, 2> HitKDTree2D;

    typedef std::map<pandora::HitType, const pandora::ClusterList &>              ClusterListMap;        
    typedef std::map<pandora::HitType, const SlidingFitDataList>                  SlidingFitDataListMap; 
    typedef std::map<pandora::HitType, const ShowerClusterList>                   ShowerClusterListMap;  
    typedef std::map<pandora::HitType, const std::reference_wrapper<HitKDTree2D> > KDTreeMap;             

    typedef MvaFeatureTool<const VertexSelectionBaseAlgorithm *const, const pandora::Vertex * const, const SlidingFitDataListMap &,
        const ClusterListMap &, const KDTreeMap &, const ShowerClusterListMap &, const float, float &>  VertexFeatureTool; 

protected:
    virtual void FilterVertexList(const pandora::VertexList *const pInputVertexList, HitKDTree2D &kdTreeU, HitKDTree2D &kdTreeV,
        HitKDTree2D &kdTreeW, pandora::VertexVector &filteredVertices) const;

    virtual void GetBeamConstants(const pandora::VertexVector &vertexVector, BeamConstants &beamConstants) const;

    virtual void GetVertexScoreList(const pandora::VertexVector &vertexVector, const BeamConstants &beamConstants, HitKDTree2D &kdTreeU,
        HitKDTree2D &kdTreeV, HitKDTree2D &kdTreeW, VertexScoreList &vertexScoreList) const = 0;

    void GetClusterLists(const pandora::StringVector &inputClusterListNames, pandora::ClusterList &clusterListU, pandora::ClusterList &clusterListV,
        pandora::ClusterList &clusterListW) const;

    void CalculateClusterSlidingFits(const pandora::ClusterList &inputClusterList, const unsigned int minClusterCaloHits,
        const unsigned int slidingFitWindow, SlidingFitDataList &slidingFitDataList) const;

    float GetBeamDeweightingScore(const BeamConstants &beamConstants, const pandora::Vertex * const pVertex) const;

    bool IsBeamModeOn() const;

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

private:
    pandora::StatusCode Run();

    void InitializeKDTrees(HitKDTree2D &kdTreeU, HitKDTree2D &kdTreeV, HitKDTree2D &kdTreeW) const;

    bool IsVertexOnHit(const pandora::Vertex *const pVertex, const pandora::HitType hitType, HitKDTree2D &kdTree) const;

    bool IsVertexInGap(const pandora::Vertex *const pVertex, const pandora::HitType hitType) const;

    void SelectTopScoreVertices(VertexScoreList &vertexScoreList, pandora::VertexList &selectedVertexList) const;

    bool AcceptVertexLocation(const pandora::Vertex *const pVertex, const pandora::VertexList &selectedVertexList) const;

    static bool SortByVertexZPosition(const pandora::Vertex *const pLhs, const pandora::Vertex *const pRhs);

private:
    pandora::StringVector   m_inputCaloHitListNames;        
    std::string             m_outputVertexListName;         

    bool                    m_replaceCurrentVertexList;     

    bool                    m_beamMode;                     
    float                   m_nDecayLengthsInZSpan;         

    bool                    m_selectSingleVertex;           
    unsigned int            m_maxTopScoreSelections;        

    float                   m_maxOnHitDisplacement;         

    float                   m_minCandidateDisplacement;     
    float                   m_minCandidateScoreFraction;    

    bool                    m_useDetectorGaps;              
    float                   m_gapTolerance;                 

    bool                    m_isEmptyViewAcceptable;        
    unsigned int            m_minVertexAcceptableViews;     
};

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

inline float VertexSelectionBaseAlgorithm::GetBeamDeweightingScore(const BeamConstants &beamConstants, const pandora::Vertex * const pVertex) const
{
    const float vertexMinZ(std::max(pVertex->GetPosition().GetZ(), beamConstants.GetMinZCoordinate()));
    return (beamConstants.GetMinZCoordinate() - vertexMinZ) * beamConstants.GetDecayConstant();
}

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

inline bool VertexSelectionBaseAlgorithm::IsBeamModeOn() const
{
    return m_beamMode;
}

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

inline VertexSelectionBaseAlgorithm::VertexScore::VertexScore(const pandora::Vertex *const pVertex, const float score) :
    m_pVertex(pVertex),
    m_score(score)
{
}

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

inline const pandora::Vertex *VertexSelectionBaseAlgorithm::VertexScore::GetVertex() const
{
    return m_pVertex;
}

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

inline float VertexSelectionBaseAlgorithm::VertexScore::GetScore() const
{
    return m_score;
}

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

inline bool VertexSelectionBaseAlgorithm::VertexScore::operator< (const VertexScore &rhs) const
{
    return (this->GetScore() > rhs.GetScore());
}

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

inline float VertexSelectionBaseAlgorithm::BeamConstants::GetMinZCoordinate() const
{
    return m_minZCoordinate.Get();
}

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

inline float VertexSelectionBaseAlgorithm::BeamConstants::GetDecayConstant() const
{
    return m_decayConstant.Get();
}

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

inline void VertexSelectionBaseAlgorithm::BeamConstants::SetConstants(const float minZCoordinate, const float decayConstant)
{
    m_minZCoordinate = minZCoordinate;
    m_decayConstant = decayConstant;
}

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

inline const pandora::CartesianVector &VertexSelectionBaseAlgorithm::SlidingFitData::GetMinLayerDirection() const
{
    return m_minLayerDirection;
}

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

inline const pandora::CartesianVector &VertexSelectionBaseAlgorithm::SlidingFitData::GetMaxLayerDirection() const
{
    return m_maxLayerDirection;
}

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

inline const pandora::CartesianVector &VertexSelectionBaseAlgorithm::SlidingFitData::GetMinLayerPosition() const
{
    return m_minLayerPosition;
}

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

inline const pandora::CartesianVector &VertexSelectionBaseAlgorithm::SlidingFitData::GetMaxLayerPosition() const
{
    return m_maxLayerPosition;
}

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

inline const pandora::Cluster *VertexSelectionBaseAlgorithm::SlidingFitData::GetCluster() const
{
    return m_pCluster;
}

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

inline const pandora::ClusterList &VertexSelectionBaseAlgorithm::ShowerCluster::GetClusters() const
{
    return m_clusterList;
}

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

inline const TwoDSlidingFitResult &VertexSelectionBaseAlgorithm::ShowerCluster::GetFit() const
{
    return m_twoDSlidingFitResult;
}

} // namespace lar_content

#endif // #ifndef LAR_VERTEX_SELECTION_BASE_ALGORITHM_H