ThreeViewTrackFragmentsAlgorithm.h

Go to the documentation of this file.

 
#ifndef LAR_THREE_VIEW_TRACK_FRAGMENTS_ALGORITHM_H
#define LAR_THREE_VIEW_TRACK_FRAGMENTS_ALGORITHM_H 1
 
#include "Pandora/Algorithm.h"
#include "Pandora/AlgorithmTool.h"
 
#include "larpandoracontent/LArObjects/LArTrackOverlapResult.h"
 
#include "larpandoracontent/LArThreeDReco/LArThreeDBase/NViewTrackMatchingAlgorithm.h"
#include "larpandoracontent/LArThreeDReco/LArThreeDBase/ThreeViewMatchingControl.h"
 
#include <unordered_map>
 
namespace lar_content
{
 
class FragmentTensorTool;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class ThreeViewTrackFragmentsAlgorithm : public NViewTrackMatchingAlgorithm<ThreeViewMatchingControl<FragmentOverlapResult>>
{
public:
    typedef NViewTrackMatchingAlgorithm<ThreeViewMatchingControl<FragmentOverlapResult>> BaseAlgorithm;
 
    ThreeViewTrackFragmentsAlgorithm();
 
    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 ExamineOverlapContainer();
    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 ThreeViewTrackFragmentsAlgorithm::MatchingType::TensorType TensorType;
    typedef std::vector<TensorType::ElementList::const_iterator> IteratorList;
 
    virtual bool Run(ThreeViewTrackFragmentsAlgorithm *const pAlgorithm, TensorType &overlapTensor) = 0;
};
 
} // namespace lar_content
 
#endif // #ifndef LAR_THREE_VIEW_TRACK_FRAGMENTS_ALGORITHM_H