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