TransverseAssociationAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_TRANSVERSE_ASSOCIATION_ALGORITHM_H
#define LAR_TRANSVERSE_ASSOCIATION_ALGORITHM_H 1

#include "Pandora/Algorithm.h"

#include "larpandoracontent/LArTwoDReco/LArClusterAssociation/ClusterAssociationAlgorithm.h"

namespace lar_content
{

template <typename, unsigned int>
class KDTreeLinkerAlgo;
template <typename, unsigned int>
class KDTreeNodeInfoT;

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

class TransverseAssociationAlgorithm : public ClusterAssociationAlgorithm
{
public:
    TransverseAssociationAlgorithm();

private:
    class LArTransverseCluster
    {
    public:
        LArTransverseCluster(const pandora::Cluster *const pSeedCluster, const pandora::ClusterVector &associatedClusters);

        const pandora::Cluster *GetSeedCluster() const;

        const pandora::ClusterVector &GetAssociatedClusters() const;

        const pandora::CartesianVector &GetInnerVertex() const;

        const pandora::CartesianVector &GetOuterVertex() const;

        const pandora::CartesianVector &GetDirection() const;

    private:
        const pandora::Cluster *m_pSeedCluster;
        pandora::ClusterVector m_associatedClusters;
        pandora::CartesianVector m_innerVertex;
        pandora::CartesianVector m_outerVertex;
        pandora::CartesianVector m_direction;
    };

    typedef std::vector<LArTransverseCluster *> TransverseClusterList;

    typedef KDTreeLinkerAlgo<const pandora::CaloHit *, 2> HitKDTree2D;
    typedef KDTreeNodeInfoT<const pandora::CaloHit *, 2> HitKDNode2D;
    typedef std::vector<HitKDNode2D> HitKDNode2DList;

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

    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
    void GetListOfCleanClusters(const pandora::ClusterList *const pClusterList, pandora::ClusterVector &clusterVector) const;
    void PopulateClusterAssociationMap(const pandora::ClusterVector &clusterVector, ClusterAssociationMap &clusterAssociationMap) const;
    bool IsExtremalCluster(const bool isForward, const pandora::Cluster *const pCurrentCluster, const pandora::Cluster *const pTestCluster) const;

    void GetNearbyClusterMap(const pandora::ClusterVector &allClusters, ClusterToClustersMap &nearbyClusters) const;

    void SortInputClusters(const pandora::ClusterVector &inputClusters, pandora::ClusterVector &shortClusters, pandora::ClusterVector &transverseMediumClusters,
        pandora::ClusterVector &longitudinalMediumClusters, pandora::ClusterVector &longClusters) const;

    void FillReducedAssociationMap(const ClusterToClustersMap &nearbyClusters, const pandora::ClusterVector &firstVector,
        const pandora::ClusterVector &secondVector, ClusterAssociationMap &clusterAssociationMap) const;

    void FillAssociationMap(const ClusterToClustersMap &nearbyClusters, const pandora::ClusterVector &firstVector,
        const pandora::ClusterVector &secondVector, ClusterAssociationMap &firstAssociationMap, ClusterAssociationMap &secondAssociationMap) const;

    void FillTransverseClusterList(const ClusterToClustersMap &nearbyClusters, const pandora::ClusterVector &inputClusters,
        const ClusterAssociationMap &inputAssociationMap, TransverseClusterList &transverseClusterList) const;

    void FillTransverseAssociationMap(const ClusterToClustersMap &nearbyClusters, const TransverseClusterList &transverseClusterList,
        const ClusterAssociationMap &transverseAssociationMap, ClusterAssociationMap &clusterAssociationMap) const;

    void GetAssociatedClusters(const ClusterToClustersMap &nearbyClusters, const pandora::Cluster *const pCluster,
        const ClusterAssociationMap &inputAssociationMap, pandora::ClusterVector &associatedClusters) const;

    bool IsAssociated(const bool isForward, const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2,
        const ClusterToClustersMap &nearbyClusters) const;

    bool IsTransverseAssociated(
        const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2, const ClusterToClustersMap &nearbyClusters) const;

    bool IsTransverseAssociated(const LArTransverseCluster *const pTransverseCluster1,
        const LArTransverseCluster *const pTransverseCluster2, const ClusterToClustersMap &nearbyClusters) const;

    bool IsTransverseAssociated(const LArTransverseCluster *const pTransverseCluster, const pandora::CartesianVector &testPosition) const;

    bool IsOverlapping(const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2) const;

    float GetTransverseSpan(const pandora::Cluster *const pCluster) const;

    float GetLongitudinalSpan(const pandora::Cluster *const pCluster) const;

    float GetTransverseSpan(const pandora::Cluster *const pCluster, const pandora::ClusterVector &associatedClusters) const;

    void GetExtremalCoordinatesX(const pandora::Cluster *const pCluster, float &minX, float &maxX) const;

    void GetExtremalCoordinatesZ(const pandora::Cluster *const pCluster, float &minZ, float &maxZ) const;

    void GetExtremalCoordinatesXZ(const pandora::Cluster *const pCluster, const bool useX, float &minXZ, float &maxXZ) const;

    void GetExtremalCoordinatesX(
        const pandora::Cluster *const pCluster, pandora::CartesianVector &innerCoordinate, pandora::CartesianVector &outerCoordinate) const;

    void FillReducedAssociationMap(const ClusterAssociationMap &inputAssociationMap, ClusterAssociationMap &outputAssociationMap) const;

    void FillReducedAssociationMap(const ClusterAssociationMap &firstAssociationMap, const ClusterAssociationMap &secondAssociationMap,
        const ClusterAssociationMap &secondAssociationMapSwapped, ClusterAssociationMap &clusterAssociationMap) const;

    void FillSymmetricAssociationMap(const ClusterAssociationMap &inputAssociationMap, ClusterAssociationMap &outputAssociationMap) const;

    void FinalizeClusterAssociationMap(const ClusterAssociationMap &inputAssociationMap, ClusterAssociationMap &outputAssociationMap) const;

    float m_firstLengthCut;  
    float m_secondLengthCut; 

    float m_clusterWindow;   
    float m_clusterAngle;    
    float m_clusterCosAngle; 
    float m_clusterTanAngle; 

    float m_maxTransverseOverlap;   
    float m_maxProjectedOverlap;    
    float m_maxLongitudinalOverlap; 

    float m_transverseClusterMinCosTheta;     
    float m_transverseClusterMinLength;       
    float m_transverseClusterMaxDisplacement; 

    float m_searchRegionX; 
    float m_searchRegionZ; 
};

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

inline const pandora::Cluster *TransverseAssociationAlgorithm::LArTransverseCluster::GetSeedCluster() const
{
    return m_pSeedCluster;
}

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

inline const pandora::ClusterVector &TransverseAssociationAlgorithm::LArTransverseCluster::GetAssociatedClusters() const
{
    return m_associatedClusters;
}

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

inline const pandora::CartesianVector &TransverseAssociationAlgorithm::LArTransverseCluster::GetInnerVertex() const
{
    return m_innerVertex;
}

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

inline const pandora::CartesianVector &TransverseAssociationAlgorithm::LArTransverseCluster::GetOuterVertex() const
{
    return m_outerVertex;
}

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

inline const pandora::CartesianVector &TransverseAssociationAlgorithm::LArTransverseCluster::GetDirection() const
{
    return m_direction;
}

} // namespace lar_content

#endif // #ifndef LAR_TRANSVERSE_ASSOCIATION_ALGORITHM_H