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/ThreeViewTransverseTracksAlgorithm.h"

#include <unordered_map>

namespace lar_content
{

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

    bool Run(ThreeViewTransverseTracksAlgorithm *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(ThreeViewTransverseTracksAlgorithm *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(ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const TensorType::Element &element,
        pandora::ClusterSet &usedClusters, ClusterMergeMap &clusterMergeMap) const;

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

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

    void GetSegmentOverlapMap(ThreeViewTransverseTracksAlgorithm *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