MissingTrackSegmentTool.h

Go to the documentation of this file.

#ifndef MISSING_TRACK_SEGMENT_TOOL_H
#define MISSING_TRACK_SEGMENT_TOOL_H 1

#include "larpandoracontent/LArThreeDReco/LArTransverseTrackMatching/ThreeDTransverseTracksAlgorithm.h"

#include <unordered_map>

namespace lar_content
{

class MissingTrackSegmentTool : public TransverseTensorTool
{
public:
    MissingTrackSegmentTool();

    bool Run(ThreeDTransverseTracksAlgorithm *const pAlgorithm, TensorType &overlapTensor);

private:
    class Particle
    {
    public:
        Particle(const TensorType::Element &element);

        const pandora::Cluster *m_pShortCluster;            
        const pandora::Cluster *m_pCluster1;                
        const pandora::Cluster *m_pCluster2;                
        pandora::HitType        m_shortHitType;             
        pandora::HitType        m_hitType1;                 
        pandora::HitType        m_hitType2;                 
        float                   m_shortMinX;                
        float                   m_shortMaxX;                
        float                   m_longMinX;                 
        float                   m_longMaxX;                 
    };

    class SegmentOverlap
    {
    public:
        SegmentOverlap();

        unsigned int            m_nSamplingPoints;          
        unsigned int            m_nMatchedSamplingPoints;   
        float                   m_pseudoChi2Sum;            
        float                   m_matchedSamplingMinX;      
        float                   m_matchedSamplingMaxX;      
    };

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

    typedef std::unordered_map<const pandora::Cluster*, SegmentOverlap> SegmentOverlapMap;
    typedef std::unordered_map<const pandora::Cluster*, pandora::ClusterList> ClusterMergeMap;

    void FindTracks(ThreeDTransverseTracksAlgorithm *const pAlgorithm, const TensorType &overlapTensor, ProtoParticleVector &protoParticleVector,
        ClusterMergeMap &clusterMergeMap) const;

    void SelectElements(const TensorType::ElementList &elementList, const pandora::ClusterSet &usedClusters, IteratorList &iteratorList) const;

    bool PassesParticleChecks(ThreeDTransverseTracksAlgorithm *const pAlgorithm, const TensorType::Element &element, pandora::ClusterSet &usedClusters,
        ClusterMergeMap &clusterMergeMap) const;

    void GetCandidateClusters(ThreeDTransverseTracksAlgorithm *const pAlgorithm, const Particle &particle, pandora::ClusterList &candidateClusters) const;

    void GetSlidingFitResultMap(ThreeDTransverseTracksAlgorithm *const pAlgorithm, const pandora::ClusterList &candidateClusterList,
        TwoDSlidingFitResultMap &slidingFitResultMap) const;

    void GetSegmentOverlapMap(ThreeDTransverseTracksAlgorithm *const pAlgorithm, const Particle &particle,
        const TwoDSlidingFitResultMap &slidingFitResultMap, SegmentOverlapMap &segmentOverlapMap) const;

    bool MakeDecisions(const Particle &particle, const TwoDSlidingFitResultMap &slidingFitResultMap, const SegmentOverlapMap &segmentOverlapMap,
        pandora::ClusterSet &usedClusters, ClusterMergeMap &clusterMergeMap) const;

    bool PassesSamplingCuts(const SegmentOverlap &segmentOverlap) const;

    bool IsPossibleMerge(const pandora::Cluster *const pCluster, const Particle &particle, const SegmentOverlap &segmentOverlap,
        const TwoDSlidingFitResultMap &slidingFitResultMap) const;

    float           m_minMatchedFraction;               
    unsigned int    m_minMatchedSamplingPoints;         
    unsigned int    m_minMatchedSamplingPointRatio;     

    float           m_minInitialXOverlapFraction;       
    float           m_minFinalXOverlapFraction;         

    unsigned int    m_minCaloHitsInCandidateCluster;    
    float           m_pseudoChi2Cut;                    

    unsigned int    m_makePfoMinSamplingPoints;         
    unsigned int    m_makePfoMinMatchedSamplingPoints;  
    float           m_makePfoMinMatchedFraction;        
    float           m_makePfoMaxImpactParameter;        

    float           m_mergeMaxChi2PerSamplingPoint;     
    float           m_mergeXContainmentTolerance;       
};

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

inline MissingTrackSegmentTool::SegmentOverlap::SegmentOverlap() :
    m_nSamplingPoints(0),
    m_nMatchedSamplingPoints(0),
    m_pseudoChi2Sum(0.f),
    m_matchedSamplingMinX(std::numeric_limits<float>::max()),
    m_matchedSamplingMaxX(-std::numeric_limits<float>::max())
{
}

} // namespace lar_content

#endif // #ifndef MISSING_TRACK_SEGMENT_TOOL_H