LArOverlapMatrix.h

Go to the documentation of this file.

 
#ifndef LAR_OVERLAP_MATRIX_H
#define LAR_OVERLAP_MATRIX_H 1
 
#include "Pandora/PandoraInternal.h"
 
#include <unordered_map>
#include <vector>
 
namespace lar_content
{
 
template <typename T>
class OverlapMatrix
{
public:
    typedef T OverlapResult;
 
    class Element
    {
    public:
        Element(const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2, const OverlapResult &overlapResult);
 
        const pandora::Cluster *GetCluster1() const;
 
        const pandora::Cluster *GetCluster2() const;
 
        const OverlapResult &GetOverlapResult() const;
 
        bool operator<(const Element &rhs) const;
 
    private:
        const pandora::Cluster *m_pCluster1; 
        const pandora::Cluster *m_pCluster2; 
        OverlapResult m_overlapResult;       
    };
 
    typedef std::vector<Element> ElementList;
 
    void GetUnambiguousElements(const bool ignoreUnavailable, ElementList &elementList) const;
 
    bool DefaultAmbiguityFunction(const pandora::ClusterList &clusterList1, const pandora::ClusterList &clusterList2,
        const pandora::Cluster *&pCluster1, const pandora::Cluster *&pCluster2) const;
 
    void GetNConnections(const pandora::Cluster *const pCluster, const bool ignoreUnavailable, unsigned int &n1, unsigned int &n2) const;
 
    void GetConnectedElements(const pandora::Cluster *const pCluster, const bool ignoreUnavailable, ElementList &elementList) const;
 
    void GetConnectedElements(const pandora::Cluster *const pCluster, const bool ignoreUnavailable, ElementList &elementList,
        unsigned int &n1, unsigned int &n2) const;
 
    typedef std::unordered_map<const pandora::Cluster *, pandora::ClusterList> ClusterNavigationMap;
    typedef std::unordered_map<const pandora::Cluster *, OverlapResult> OverlapList;
    typedef std::unordered_map<const pandora::Cluster *, OverlapList> TheMatrix;
 
    typedef typename TheMatrix::const_iterator const_iterator;
 
    const_iterator begin() const;
 
    const_iterator end() const;
 
    void GetSortedKeyClusters(pandora::ClusterVector &sortedKeyClusters) const;
 
    const OverlapResult &GetOverlapResult(const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2) const;
 
    const OverlapList &GetOverlapList(const pandora::Cluster *const pCluster1) const;
 
    const ClusterNavigationMap &GetClusterNavigationMap12() const;
 
    const ClusterNavigationMap &GetClusterNavigationMap21() const;
 
    void SetOverlapResult(const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2, const OverlapResult &overlapResult);
 
    void ReplaceOverlapResult(const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2, const OverlapResult &overlapResult);
 
    void RemoveCluster(const pandora::Cluster *const pCluster);
 
    void Clear();
 
private:
    void GetConnectedElements(const pandora::Cluster *const pCluster, const bool ignoreUnavailable, ElementList &elementList,
        pandora::ClusterList &clusterList1, pandora::ClusterList &clusterList2) const;
 
    void ExploreConnections(const pandora::Cluster *const pCluster, const bool ignoreUnavailable, pandora::ClusterList &clusterList1,
        pandora::ClusterList &clusterList2) const;
 
    TheMatrix m_overlapMatrix;                     
    ClusterNavigationMap m_clusterNavigationMap12; 
    ClusterNavigationMap m_clusterNavigationMap21; 
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline void OverlapMatrix<T>::GetNConnections(const pandora::Cluster *const pCluster, const bool ignoreUnavailable, unsigned int &n1, unsigned int &n2) const
{
    ElementList elementList;
    this->GetConnectedElements(pCluster, ignoreUnavailable, elementList, n1, n2);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline void OverlapMatrix<T>::GetConnectedElements(const pandora::Cluster *const pCluster, const bool ignoreUnavailable, ElementList &elementList) const
{
    unsigned int n1(0), n2(0);
    this->GetConnectedElements(pCluster, ignoreUnavailable, elementList, n1, n2);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline typename OverlapMatrix<T>::const_iterator OverlapMatrix<T>::begin() const
{
    return m_overlapMatrix.begin();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline typename OverlapMatrix<T>::const_iterator OverlapMatrix<T>::end() const
{
    return m_overlapMatrix.end();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline const typename OverlapMatrix<T>::OverlapResult &OverlapMatrix<T>::GetOverlapResult(
    const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2) const
{
    const OverlapList &overlapList(this->GetOverlapList(pCluster1));
    typename OverlapList::const_iterator iter = overlapList.find(pCluster2);
 
    if (overlapList.end() == iter)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_FOUND);
 
    return iter->second;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline const typename OverlapMatrix<T>::OverlapList &OverlapMatrix<T>::GetOverlapList(const pandora::Cluster *const pCluster1) const
{
    typename TheMatrix::const_iterator iter = m_overlapMatrix.find(pCluster1);
 
    if (m_overlapMatrix.end() == iter)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_FOUND);
 
    return iter->second;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline const typename OverlapMatrix<T>::ClusterNavigationMap &OverlapMatrix<T>::GetClusterNavigationMap12() const
{
    return m_clusterNavigationMap12;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline const typename OverlapMatrix<T>::ClusterNavigationMap &OverlapMatrix<T>::GetClusterNavigationMap21() const
{
    return m_clusterNavigationMap21;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline void OverlapMatrix<T>::Clear()
{
    m_overlapMatrix.clear();
    m_clusterNavigationMap12.clear();
    m_clusterNavigationMap21.clear();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline OverlapMatrix<T>::Element::Element(
    const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2, const OverlapResult &overlapResult) :
    m_pCluster1(pCluster1),
    m_pCluster2(pCluster2),
    m_overlapResult(overlapResult)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline const pandora::Cluster *OverlapMatrix<T>::Element::GetCluster1() const
{
    return m_pCluster1;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline const pandora::Cluster *OverlapMatrix<T>::Element::GetCluster2() const
{
    return m_pCluster2;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline const typename OverlapMatrix<T>::OverlapResult &OverlapMatrix<T>::Element::GetOverlapResult() const
{
    return m_overlapResult;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
bool OverlapMatrix<T>::Element::operator<(const Element &rhs) const
{
    if (this == &rhs)
        return false;
 
    return (this->GetOverlapResult() < rhs.GetOverlapResult());
}
 
} // namespace lar_content
 
#endif // #ifndef LAR_OVERLAP_MATRIX_H