TrainedVertexSelectionAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_TRAINED_VERTEX_SELECTION_ALGORITHM_H
#define LAR_TRAINED_VERTEX_SELECTION_ALGORITHM_H 1

#include "Api/PandoraContentApi.h"

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

#include "larpandoracontent/LArHelpers/LArMCParticleHelper.h"

#include "larpandoracontent/LArVertex/VertexSelectionBaseAlgorithm.h"

#include <random>

namespace lar_content
{

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

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

class TrainedVertexSelectionAlgorithm : public VertexSelectionBaseAlgorithm
{
public:
    class VertexFeatureInfo
    {
    public:
        VertexFeatureInfo(const float beamDeweighting, const float rPhiFeature, const float energyKick, const float localAsymmetry,
            const float globalAsymmetry, const float showerAsymmetry, const float dEdxAsymmetry, const float vertexEnergy);

        float m_beamDeweighting; 
        float m_rPhiFeature;     
        float m_energyKick;      
        float m_localAsymmetry;  
        float m_globalAsymmetry; 
        float m_showerAsymmetry; 
        float m_dEdxAsymmetry;   
        float m_vertexEnergy;    
    };

    typedef std::map<const pandora::Vertex *const, VertexFeatureInfo> VertexFeatureInfoMap;

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

    class VertexSharedFeatureInfo
    {
    public:
        VertexSharedFeatureInfo(const float separation, const float axisHits);

        float m_separation; 
        float m_axisHits;   
    };

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

    class EventFeatureInfo
    {
    public:
        EventFeatureInfo(const float eventShoweryness, const float eventEnergy, const float eventArea, const float longitudinality,
            const unsigned int nHits, const unsigned int nClusters, const unsigned int nCandidates);

        float m_eventShoweryness;   
        float m_eventEnergy;        
        float m_eventArea;          
        float m_longitudinality;    
        unsigned int m_nHits;       
        unsigned int m_nClusters;   
        unsigned int m_nCandidates; 
    };

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

    TrainedVertexSelectionAlgorithm();

protected:
    typedef std::pair<pandora::CartesianVector, pandora::CartesianVector> ClusterEndPoints;
    typedef std::map<const pandora::Cluster *const, ClusterEndPoints> ClusterEndPointsMap;
    typedef std::vector<LArMvaHelper::MvaFeatureVector> FeatureListVector;
    typedef std::vector<pandora::VertexVector> VectorOfVertexVectors;

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

    void CalculateShowerClusterList(const pandora::ClusterList &inputClusterList, ShowerClusterList &showerClusterList) const;

    void GetShowerLikeClusterEndPoints(
        const pandora::ClusterList &clusterList, pandora::ClusterList &showerLikeClusters, ClusterEndPointsMap &clusterEndPointsMap) const;

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

    typedef std::unordered_map<const pandora::CaloHit *, const pandora::Cluster *> HitToClusterMap;

    void PopulateKdTree(const pandora::ClusterList &clusterList, HitKDTree2D &kdTree, HitToClusterMap &hitToClusterMap) const;

    bool AddClusterToShower(const ClusterEndPointsMap &clusterEndPointsMap, pandora::ClusterList &availableShowerLikeClusters,
        const pandora::Cluster *const pCluster, pandora::ClusterList &showerCluster) const;

    bool AddClusterToShower(HitKDTree2D &kdTree, const HitToClusterMap &hitToClusterMap, pandora::ClusterList &availableShowerLikeClusters,
        const pandora::Cluster *const pCluster, pandora::ClusterList &showerCluster) const;

    EventFeatureInfo CalculateEventFeatures(const pandora::ClusterList &clusterListU, const pandora::ClusterList &clusterListV,
        const pandora::ClusterList &clusterListW, const pandora::VertexVector &vertexVector) const;

    void IncrementShoweryParameters(const pandora::ClusterList &clusterList, unsigned int &nShoweryHits, unsigned int &nHits, float &eventEnergy) const;

    bool IsClusterShowerLike(const pandora::Cluster *const pCluster) const;

    void GetLegacyEventShapeFeatures(const pandora::ClusterList &clusterList, float &eventVolume, float &longitudinality) const;

    void GetEventShapeFeatures(const ClusterListMap &clusterListMap, float &eventArea, float &longitudinality) const;

    void Get2DSpan(const pandora::ClusterList &clusterList, float &xSpan, float &zSpan) const;

    void UpdateSpanCoordinate(
        const float minPositionCoord, const float maxPositionCoord, pandora::InputFloat &minCoord, pandora::InputFloat &maxCoord) const;

    float GetCoordinateSpan(const pandora::InputFloat &minCoord, const pandora::InputFloat &maxCoord) const;

    void AddEventFeaturesToVector(const EventFeatureInfo &eventFeatureInfo, LArMvaHelper::MvaFeatureVector &featureVector) const;

    void PopulateVertexFeatureInfoMap(const BeamConstants &beamConstants, const ClusterListMap &clusterListMap,
        const SlidingFitDataListMap &slidingFitDataListMap, const ShowerClusterListMap &showerClusterListMap, const KDTreeMap &kdTreeMap,
        const pandora::Vertex *const pVertex, VertexFeatureInfoMap &vertexFeatureInfoMap) const;

    void PopulateInitialScoreList(VertexFeatureInfoMap &vertexFeatureInfoMap, const pandora::Vertex *const pVertex, VertexScoreList &initialScoreList) const;

    void GetBestRegionVertices(VertexScoreList &initialScoreList, pandora::VertexVector &bestRegionVertices) const;

    void ProduceTrainingSets(const pandora::VertexVector &vertexVector, const pandora::VertexVector &bestRegionVertices,
        VertexFeatureInfoMap &vertexFeatureInfoMap, const LArMvaHelper::MvaFeatureVector &eventFeatureList, const KDTreeMap &kdTreeMap) const;

    void CalculateRPhiScores(pandora::VertexVector &vertexVector, VertexFeatureInfoMap &vertexFeatureInfoMap, const KDTreeMap &kdTreeMap) const;

    std::string GetInteractionType() const;

    const pandora::Vertex *ProduceTrainingExamples(const pandora::VertexVector &vertexVector, const VertexFeatureInfoMap &vertexFeatureInfoMap,
        std::bernoulli_distribution &coinFlip, std::mt19937 &generator, const std::string &interactionType, const std::string &trainingOutputFile,
        const LArMvaHelper::MvaFeatureVector &eventFeatureList, const KDTreeMap &kdTreeMap, const float maxRadius, const bool useRPhi) const;

    void GetBestVertex(const pandora::VertexVector &vertexVector, const pandora::Vertex *&pBestVertex, float &bestVertexDr) const;

    void GetSharedFeatures(const pandora::Vertex *const pVertex1, const pandora::Vertex *const pVertex2, const KDTreeMap &kdTreeMap,
        float &separation, float &axisHits) const;

    void IncrementSharedAxisValues(const pandora::CartesianVector pos1, const pandora::CartesianVector pos2, HitKDTree2D &kdTree, float &axisHits) const;

    bool IsHitInBox(const pandora::CartesianVector &hitPos, const pandora::CartesianVector &point1, const pandora::CartesianVector &point2,
        const pandora::CartesianVector &point3, const pandora::CartesianVector &point4) const;

    void AddVertexFeaturesToVector(const VertexFeatureInfo &vertexFeatureInfo, LArMvaHelper::MvaFeatureVector &featureVector, const bool useRPhi) const;

    void AddSharedFeaturesToVector(const VertexSharedFeatureInfo &vertexSharedFeatureInfo, LArMvaHelper::MvaFeatureVector &featureVector) const;

    void PopulateFinalVertexScoreList(const VertexFeatureInfoMap &vertexFeatureInfoMap, const pandora::Vertex *const pFavouriteVertex,
        const pandora::VertexVector &vertexVector, VertexScoreList &finalVertexScoreList) const;

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

    VertexFeatureTool::FeatureToolVector m_featureToolVector; 
    bool m_trainingSetMode;                                   
    bool m_allowClassifyDuringTraining;                       
    float m_mcVertexXCorrection;                              
    std::string m_trainingOutputFileRegion;                   
    std::string m_trainingOutputFileVertex;                   
    std::string m_mcParticleListName;                         
    std::string m_caloHitListName;                            

    pandora::StringVector m_inputClusterListNames; 
    unsigned int m_minClusterCaloHits;             
    unsigned int m_slidingFitWindow;               
    float m_minShowerSpineLength;                  

    float m_beamDeweightingConstant; 
    float m_localAsymmetryConstant;  
    float m_globalAsymmetryConstant; 
    float m_showerAsymmetryConstant; 
    float m_energyKickConstant;      

    float m_showerClusteringDistance;         
    unsigned int m_minShowerClusterHits;      
    bool m_useShowerClusteringApproximation;  
    float m_regionRadius;                     
    float m_rPhiFineTuningRadius;             
    float m_maxTrueVertexRadius;              
    bool m_useRPhiFeatureForRegion;           
    bool m_dropFailedRPhiFastScoreCandidates; 
    bool m_testBeamMode;                      
    bool m_legacyEventShapes;                 
    bool m_legacyVariables;                   
};

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

inline TrainedVertexSelectionAlgorithm::VertexFeatureInfo::VertexFeatureInfo(const float beamDeweighting, const float rPhiFeature, const float energyKick,
    const float localAsymmetry, const float globalAsymmetry, const float showerAsymmetry, const float dEdxAsymmetry, const float vertexEnergy) :
    m_beamDeweighting(beamDeweighting),
    m_rPhiFeature(rPhiFeature),
    m_energyKick(energyKick),
    m_localAsymmetry(localAsymmetry),
    m_globalAsymmetry(globalAsymmetry),
    m_showerAsymmetry(showerAsymmetry),
    m_dEdxAsymmetry(dEdxAsymmetry),
    m_vertexEnergy(vertexEnergy)
{
}

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

inline TrainedVertexSelectionAlgorithm::EventFeatureInfo::EventFeatureInfo(const float eventShoweryness, const float eventEnergy,
    const float eventArea, const float longitudinality, const unsigned int nHits, const unsigned int nClusters, const unsigned int nCandidates) :
    m_eventShoweryness(eventShoweryness),
    m_eventEnergy(eventEnergy),
    m_eventArea(eventArea),
    m_longitudinality(longitudinality),
    m_nHits(nHits),
    m_nClusters(nClusters),
    m_nCandidates(nCandidates)
{
}

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

inline TrainedVertexSelectionAlgorithm::VertexSharedFeatureInfo::VertexSharedFeatureInfo(const float separation, const float axisHits) :
    m_separation(separation),
    m_axisHits(axisHits)
{
}

} // namespace lar_content

#endif // #ifndef LAR_TRAINED_VERTEX_SELECTION_ALGORITHM_H