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