ThreeDTrackFragmentsAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_THREE_D_TRACK_FRAGMENTS_ALGORITHM_H
#define LAR_THREE_D_TRACK_FRAGMENTS_ALGORITHM_H 1

#include "Pandora/Algorithm.h"
#include "Pandora/AlgorithmTool.h"

#include "larpandoracontent/LArObjects/LArTrackOverlapResult.h"

#include "larpandoracontent/LArThreeDReco/LArThreeDBase/ThreeDTracksBaseAlgorithm.h"

#include <unordered_map>

namespace lar_content
{

class FragmentTensorTool;

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

class ThreeDTrackFragmentsAlgorithm : public ThreeDTracksBaseAlgorithm<FragmentOverlapResult>
{
public:
    ThreeDTrackFragmentsAlgorithm();

    void UpdateForNewCluster(const pandora::Cluster *const pNewCluster);

    void RebuildClusters(const pandora::ClusterList &rebuildList, pandora::ClusterList &newClusters) const;

protected:
    void PerformMainLoop();
    void CalculateOverlapResult(const pandora::Cluster *const pClusterU, const pandora::Cluster *const pClusterV, const pandora::Cluster *const pClusterW);

    pandora::StatusCode CalculateOverlapResult(const TwoDSlidingFitResult &fitResult1, const TwoDSlidingFitResult &fitResult2,
        const pandora::ClusterList &inputClusterList, const pandora::Cluster *&pBestMatchedCluster, FragmentOverlapResult &fragmentOverlapResult) const;

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

    pandora::StatusCode GetProjectedPositions(const TwoDSlidingFitResult &fitResult1, const TwoDSlidingFitResult &fitResult2,
        pandora::CartesianPointVector &projectedPositions) const;

    pandora::StatusCode GetMatchedHits(const pandora::ClusterList &inputClusterList, const pandora::CartesianPointVector &projectedPositions,
        HitToClusterMap &hitToClusterMap, pandora::CaloHitList &matchedCaloHits) const;

    pandora::StatusCode GetMatchedClusters(const pandora::CaloHitList &matchedHits, const HitToClusterMap &hitToClusterMap,
        pandora::ClusterList &matchedClusters, const pandora::Cluster *&pBestMatchedCluster) const;

    void GetFragmentOverlapResult(const pandora::CartesianPointVector &projectedPositions, const pandora::CaloHitList &matchedHits,
        const pandora::ClusterList &matchedClusters, FragmentOverlapResult &fragmentOverlapResult) const;

    bool CheckMatchedClusters(const pandora::CartesianPointVector &projectedPositions, const pandora::ClusterList &matchedClusters) const;

    bool CheckOverlapResult(const FragmentOverlapResult &overlapResult) const;

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

    typedef std::unordered_map<const pandora::Cluster*, unsigned int> ClusterToMatchedHitsMap;

    std::string         m_reclusteringAlgorithmName;        

    typedef std::vector<FragmentTensorTool*> TensorToolVector;
    TensorToolVector    m_algorithmToolVector;              

    unsigned int        m_nMaxTensorToolRepeats;            

    float               m_minXOverlap;                      
    float               m_minXOverlapFraction;              
    float               m_maxPointDisplacementSquared;      
    float               m_minMatchedSamplingPointFraction;  
    unsigned int        m_minMatchedHits;                   
};

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

class FragmentTensorTool : public pandora::AlgorithmTool
{
public:
    typedef ThreeDTrackFragmentsAlgorithm::TensorType TensorType;
    typedef std::vector<TensorType::ElementList::const_iterator> IteratorList;

    virtual bool Run(ThreeDTrackFragmentsAlgorithm *const pAlgorithm, TensorType &overlapTensor) = 0;
};

} // namespace lar_content

#endif // #ifndef LAR_THREE_D_TRACK_FRAGMENTS_ALGORITHM_H