DeltaRayMatchingContainers.cc

Go to the documentation of this file.

 
#include "Pandora/PandoraEnumeratedTypes.h"
 
#include "Objects/Cluster.h"
 
#include "larpandoracontent/LArHelpers/LArClusterHelper.h"
#include "larpandoracontent/LArHelpers/LArPfoHelper.h"
 
#include "larpandoracontent/LArThreeDReco/LArCosmicRay/DeltaRayMatchingContainers.h"
 
using namespace pandora;
 
namespace lar_content
{
 
DeltaRayMatchingContainers::DeltaRayMatchingContainers() : m_searchRegion1D(3.f)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::FillContainers(const PfoList &inputPfoList, const ClusterList &inputClusterList1,
    const ClusterList &inputClusterList2, const ClusterList &inputClusterList3)
{
    this->FillHitToClusterMap(inputClusterList1);
    this->FillHitToClusterMap(inputClusterList2);
    this->FillHitToClusterMap(inputClusterList3);
 
    this->FillClusterProximityMap(inputClusterList1);
    this->FillClusterProximityMap(inputClusterList2);
    this->FillClusterProximityMap(inputClusterList3);
 
    this->FillClusterToPfoMaps(inputPfoList);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::FillHitToClusterMap(const ClusterList &inputClusterList)
{
    for (const Cluster *const pCluster : inputClusterList)
        this->AddToClusterMap(pCluster);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::AddToClusterMap(const Cluster *const pCluster)
{
    const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
    HitToClusterMap &hitToClusterMap((hitType == TPC_VIEW_U) ? m_hitToClusterMapU : (hitType == TPC_VIEW_V) ? m_hitToClusterMapV : m_hitToClusterMapW);
 
    CaloHitList caloHitList;
    pCluster->GetOrderedCaloHitList().FillCaloHitList(caloHitList);
 
    for (const CaloHit *const pCaloHit : caloHitList)
        hitToClusterMap[pCaloHit] = pCluster;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::FillClusterProximityMap(const ClusterList &inputClusterList)
{
    if (inputClusterList.empty())
        return;
 
    const HitType hitType(LArClusterHelper::GetClusterHitType(inputClusterList.front()));
 
    this->BuildKDTree(hitType);
 
    for (const Cluster *const pCluster : inputClusterList)
        this->AddToClusterProximityMap(pCluster);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::BuildKDTree(const HitType hitType)
{
    const HitToClusterMap &hitToClusterMap((hitType == TPC_VIEW_U) ? m_hitToClusterMapU : (hitType == TPC_VIEW_V) ? m_hitToClusterMapV : m_hitToClusterMapW);
    HitKDTree2D &kdTree((hitType == TPC_VIEW_U) ? m_kdTreeU : (hitType == TPC_VIEW_V) ? m_kdTreeV : m_kdTreeW);
 
    CaloHitList allCaloHits;
 
    for (auto &entry : hitToClusterMap)
        allCaloHits.push_back(entry.first);
 
    HitKDNode2DList hitKDNode2DList;
    KDTreeBox hitsBoundingRegion2D(fill_and_bound_2d_kd_tree(allCaloHits, hitKDNode2DList));
 
    kdTree.build(hitKDNode2DList, hitsBoundingRegion2D);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::AddToClusterProximityMap(const Cluster *const pCluster)
{
    const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
    const HitToClusterMap &hitToClusterMap((hitType == TPC_VIEW_U) ? m_hitToClusterMapU : (hitType == TPC_VIEW_V) ? m_hitToClusterMapV : m_hitToClusterMapW);
    HitKDTree2D &kdTree((hitType == TPC_VIEW_U) ? m_kdTreeU : (hitType == TPC_VIEW_V) ? m_kdTreeV : m_kdTreeW);
    ClusterProximityMap &clusterProximityMap(
        (hitType == TPC_VIEW_U) ? m_clusterProximityMapU : (hitType == TPC_VIEW_V) ? m_clusterProximityMapV : m_clusterProximityMapW);
 
    CaloHitList caloHitList;
    pCluster->GetOrderedCaloHitList().FillCaloHitList(caloHitList);
 
    for (const CaloHit *const pCaloHit : caloHitList)
    {
        HitKDNode2DList found;
        KDTreeBox searchRegionHits(build_2d_kd_search_region(pCaloHit, m_searchRegion1D, m_searchRegion1D));
 
        kdTree.search(searchRegionHits, found);
 
        for (const auto &hit : found)
        {
            const Cluster *const pNearbyCluster(hitToClusterMap.at(hit.data));
 
            if (pNearbyCluster == pCluster)
                continue;
 
            ClusterList &nearbyClusterList(clusterProximityMap[pCluster]);
 
            if (std::find(nearbyClusterList.begin(), nearbyClusterList.end(), pNearbyCluster) == nearbyClusterList.end())
                nearbyClusterList.push_back(pNearbyCluster);
 
            ClusterList &invertedNearbyClusterList(clusterProximityMap[pNearbyCluster]);
 
            if (std::find(invertedNearbyClusterList.begin(), invertedNearbyClusterList.end(), pCluster) == invertedNearbyClusterList.end())
                invertedNearbyClusterList.push_back(pCluster);
        }
    }
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::FillClusterToPfoMaps(const PfoList &inputPfoList)
{
    for (const ParticleFlowObject *const pPfo : inputPfoList)
        this->AddClustersToPfoMaps(pPfo);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::AddClustersToPfoMaps(const ParticleFlowObject *const pPfo)
{
    for (const HitType hitType : {TPC_VIEW_U, TPC_VIEW_V, TPC_VIEW_W})
    {
        ClusterList pfoClusters;
        LArPfoHelper::GetClusters(pPfo, hitType, pfoClusters);
 
        ClusterToPfoMap &clusterToPfoMap((hitType == TPC_VIEW_U) ? m_clusterToPfoMapU : (hitType == TPC_VIEW_V) ? m_clusterToPfoMapV : m_clusterToPfoMapW);
 
        for (const Cluster *const pCluster : pfoClusters)
        {
            if (clusterToPfoMap.find(pCluster) != clusterToPfoMap.end())
                continue;
 
            clusterToPfoMap[pCluster] = pPfo;
        }
    }
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::AddClustersToContainers(const ClusterVector &newClusterVector, const PfoVector &pfoVector)
{
    for (const Cluster *const pNewCluster : newClusterVector)
        this->AddToClusterMap(pNewCluster);
 
    for (unsigned int i = 0; i < newClusterVector.size(); i++)
    {
        const Cluster *const pNewCluster(newClusterVector.at(i));
        const ParticleFlowObject *const pMuonPfo(pfoVector.at(i));
 
        this->AddToClusterProximityMap(pNewCluster);
 
        if (pMuonPfo)
            this->AddClustersToPfoMaps(pMuonPfo);
    }
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::RemoveClusterFromContainers(const Cluster *const pDeletedCluster)
{
    const HitType hitType(LArClusterHelper::GetClusterHitType(pDeletedCluster));
    HitToClusterMap &hitToClusterMap((hitType == TPC_VIEW_U) ? m_hitToClusterMapU : (hitType == TPC_VIEW_V) ? m_hitToClusterMapV : m_hitToClusterMapW);
    ClusterProximityMap &clusterProximityMap(
        (hitType == TPC_VIEW_U) ? m_clusterProximityMapU : (hitType == TPC_VIEW_V) ? m_clusterProximityMapV : m_clusterProximityMapW);
    ClusterToPfoMap &clusterToPfoMap((hitType == TPC_VIEW_U) ? m_clusterToPfoMapU : (hitType == TPC_VIEW_V) ? m_clusterToPfoMapV : m_clusterToPfoMapW);
 
    CaloHitList caloHitList;
    pDeletedCluster->GetOrderedCaloHitList().FillCaloHitList(caloHitList);
 
    for (const CaloHit *const pCaloHit : caloHitList)
    {
        const HitToClusterMap::const_iterator iter(hitToClusterMap.find(pCaloHit));
 
        if (iter == hitToClusterMap.end())
            throw StatusCodeException(STATUS_CODE_FAILURE);
 
        hitToClusterMap.erase(iter);
    }
 
    const ClusterProximityMap::const_iterator clusterProximityIter(clusterProximityMap.find(pDeletedCluster));
 
    if (clusterProximityIter != clusterProximityMap.end())
    {
        const ClusterList &nearbyClusterList(clusterProximityIter->second);
 
        for (const Cluster *const pNearbyCluster : nearbyClusterList)
        {
            const ClusterProximityMap::iterator iter(clusterProximityMap.find(pNearbyCluster));
 
            if (iter == clusterProximityMap.end())
                continue;
 
            ClusterList &invertedCloseClusters(iter->second);
 
            ClusterList::iterator invertedIter(std::find(invertedCloseClusters.begin(), invertedCloseClusters.end(), pDeletedCluster));
            invertedCloseClusters.erase(invertedIter);
        }
 
        clusterProximityMap.erase(clusterProximityIter);
    }
 
    const DeltaRayMatchingContainers::ClusterToPfoMap::const_iterator clusterToPfoIter(clusterToPfoMap.find(pDeletedCluster));
 
    if (clusterToPfoIter != clusterToPfoMap.end())
        clusterToPfoMap.erase(clusterToPfoIter);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void DeltaRayMatchingContainers::ClearContainers()
{
    m_hitToClusterMapU.clear();
    m_hitToClusterMapV.clear();
    m_hitToClusterMapW.clear();
 
    m_kdTreeU.clear();
    m_kdTreeV.clear();
    m_kdTreeW.clear();
 
    m_clusterProximityMapU.clear();
    m_clusterProximityMapV.clear();
    m_clusterProximityMapW.clear();
 
    m_clusterToPfoMapU.clear();
    m_clusterToPfoMapV.clear();
    m_clusterToPfoMapW.clear();
}
 
} // namespace lar_content