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 "Objects/Vertex.h"
#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;

    float GetVertexEnergy(const pandora::Vertex *const pVertex, const KDTreeMap &kdTreeMap) const;

    float VertexHitEnergy(const pandora::Vertex *const pVertex, const pandora::HitType hitType, HitKDTree2D &kdTree) 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