pandora_srcnav/_delta_ray_matching_algorithm_8cc_source.html

#include "Pandora/AlgorithmHeaders.h"


#include "larpandoracontent/LArHelpers/LArClusterHelper.h"

#include "larpandoracontent/LArHelpers/LArGeometryHelper.h"

#include "larpandoracontent/LArHelpers/LArPfoHelper.h"


#include "larpandoracontent/LArThreeDReco/LArCosmicRay/DeltaRayMatchingAlgorithm.h"


#include "larpandoracontent/LArUtility/KDTreeLinkerAlgoT.h"


using namespace pandora;


namespace lar_content

{


DeltaRayMatchingAlgorithm::DeltaRayMatchingAlgorithm() :

    m_minCaloHitsPerCluster(3),

    m_xOverlapWindow(1.f),

    m_distanceForMatching(5.f),

    m_pseudoChi2Cut(3.f),

    m_searchRegion1D(5.f)

{

}


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


StatusCode DeltaRayMatchingAlgorithm::Run()

{

    PfoVector pfoVector;

    this->GetAllPfos(m_parentPfoListName, pfoVector);


    if (pfoVector.empty())

    {

        if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())

            std::cout << "DeltaRayMatchingAlgorithm: pfo list " << m_parentPfoListName << " unavailable." << std::endl;


        return STATUS_CODE_SUCCESS;

    }


    this->InitializeNearbyClusterMaps();


    ClusterLengthMap clusterLengthMap;

    this->ThreeViewMatching(clusterLengthMap);

    this->TwoViewMatching(clusterLengthMap);

    this->OneViewMatching(clusterLengthMap);


    this->ClearNearbyClusterMaps();


    return STATUS_CODE_SUCCESS;

}


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


void DeltaRayMatchingAlgorithm::InitializeNearbyClusterMaps()

{

    this->ClearNearbyClusterMaps();

    this->InitializeNearbyClusterMap(m_inputClusterListNameU, m_nearbyClustersU);

    this->InitializeNearbyClusterMap(m_inputClusterListNameV, m_nearbyClustersV);

    this->InitializeNearbyClusterMap(m_inputClusterListNameW, m_nearbyClustersW);

}


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


void DeltaRayMatchingAlgorithm::InitializeNearbyClusterMap(const std::string &clusterListName, ClusterToClustersMap &nearbyClusters)

{

    const ClusterList *pClusterList = NULL;

    PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, clusterListName, pClusterList))


    if ((NULL == pClusterList) || pClusterList->empty())

        return;


    HitToClusterMap hitToClusterMap;

    CaloHitList allCaloHits;


    for (const Cluster *const pCluster : *pClusterList)

    {

        CaloHitList daughterHits;

        pCluster->GetOrderedCaloHitList().FillCaloHitList(daughterHits);

        allCaloHits.insert(allCaloHits.end(), daughterHits.begin(), daughterHits.end());


        for (const CaloHit *const pCaloHit : daughterHits)

            (void)hitToClusterMap.insert(HitToClusterMap::value_type(pCaloHit, pCluster));

    }


    HitKDTree2D kdTree;

    HitKDNode2DList hitKDNode2DList;


    KDTreeBox hitsBoundingRegion2D(fill_and_bound_2d_kd_tree(allCaloHits, hitKDNode2DList));

    kdTree.build(hitKDNode2DList, hitsBoundingRegion2D);


    for (const Cluster *const pCluster : *pClusterList)

    {

        CaloHitList daughterHits;

        pCluster->GetOrderedCaloHitList().FillCaloHitList(daughterHits);


        for (const CaloHit *const pCaloHit : daughterHits)

        {

            KDTreeBox searchRegionHits = build_2d_kd_search_region(pCaloHit, m_searchRegion1D, m_searchRegion1D);


            HitKDNode2DList found;

            kdTree.search(searchRegionHits, found);


            for (const auto &hit : found)

            {

                ClusterList &nearbyClusterList(nearbyClusters[pCluster]);

                const Cluster *const pNearbyCluster(hitToClusterMap.at(hit.data));


                if (nearbyClusterList.end() == std::find(nearbyClusterList.begin(), nearbyClusterList.end(), pNearbyCluster))

                    nearbyClusterList.push_back(pNearbyCluster);

            }

        }

    }

}


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


void DeltaRayMatchingAlgorithm::ClearNearbyClusterMaps()

{

    m_nearbyClustersU.clear();

    m_nearbyClustersV.clear();

    m_nearbyClustersW.clear();

}


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


void DeltaRayMatchingAlgorithm::GetAllPfos(const std::string &inputPfoListName, PfoVector &pfoVector) const

{

    const PfoList *pPfoList = NULL;

    PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, inputPfoListName, pPfoList));


    if (NULL == pPfoList)

        return;


    for (PfoList::const_iterator iter = pPfoList->begin(), iterEnd = pPfoList->end(); iter != iterEnd; ++iter)

        pfoVector.push_back(*iter);


    std::sort(pfoVector.begin(), pfoVector.end(), LArPfoHelper::SortByNHits);

}


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


void DeltaRayMatchingAlgorithm::GetTrackPfos(const std::string &inputPfoListName, PfoVector &pfoVector) const

{

    PfoVector inputVector;

    this->GetAllPfos(inputPfoListName, inputVector);


    for (PfoVector::const_iterator iter = inputVector.begin(), iterEnd = inputVector.end(); iter != iterEnd; ++iter)

    {

        const ParticleFlowObject *const pPfo = *iter;


        if (!LArPfoHelper::IsTrack(pPfo))

            continue;


        pfoVector.push_back(pPfo);

    }


    // ATTN Track pfo list is sorted only because the inputVector is sorted

}


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


void DeltaRayMatchingAlgorithm::GetClusters(const std::string &inputClusterListName, pandora::ClusterVector &clusterVector) const

{

    const ClusterList *pClusterList = NULL;

    PANDORA_THROW_RESULT_IF_AND_IF(

        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, inputClusterListName, pClusterList))


    if (NULL == pClusterList)

        return;


    for (ClusterList::const_iterator cIter = pClusterList->begin(), cIterEnd = pClusterList->end(); cIter != cIterEnd; ++cIter)

    {

        const Cluster *const pCluster = *cIter;


        if (!pCluster->IsAvailable() || (pCluster->GetNCaloHits() < m_minCaloHitsPerCluster))

            continue;


        clusterVector.push_back(pCluster);

    }


    std::sort(clusterVector.begin(), clusterVector.end(), LArClusterHelper::SortByNHits);

}


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


void DeltaRayMatchingAlgorithm::ThreeViewMatching(ClusterLengthMap &clusterLengthMap) const

{

    ClusterVector clustersU, clustersV, clustersW;

    this->GetClusters(m_inputClusterListNameU, clustersU);

    this->GetClusters(m_inputClusterListNameV, clustersV);

    this->GetClusters(m_inputClusterListNameW, clustersW);


    PfoLengthMap pfoLengthMap;

    ParticleList initialParticleList, finalParticleList;

    this->ThreeViewMatching(clustersU, clustersV, clustersW, clusterLengthMap, pfoLengthMap, initialParticleList);

    this->SelectParticles(initialParticleList, clusterLengthMap, finalParticleList);

    this->CreateParticles(finalParticleList);

}


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


void DeltaRayMatchingAlgorithm::TwoViewMatching(ClusterLengthMap &clusterLengthMap) const

{

    ClusterVector clustersU, clustersV, clustersW;

    this->GetClusters(m_inputClusterListNameU, clustersU);

    this->GetClusters(m_inputClusterListNameV, clustersV);

    this->GetClusters(m_inputClusterListNameW, clustersW);


    PfoLengthMap pfoLengthMap;

    ParticleList initialParticleList, finalParticleList;

    this->TwoViewMatching(clustersU, clustersV, clusterLengthMap, pfoLengthMap, initialParticleList);

    this->TwoViewMatching(clustersV, clustersW, clusterLengthMap, pfoLengthMap, initialParticleList);

    this->TwoViewMatching(clustersW, clustersU, clusterLengthMap, pfoLengthMap, initialParticleList);

    this->SelectParticles(initialParticleList, clusterLengthMap, finalParticleList);

    this->CreateParticles(finalParticleList);

}


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


void DeltaRayMatchingAlgorithm::OneViewMatching(ClusterLengthMap &clusterLengthMap) const

{

    ClusterVector clustersU, clustersV, clustersW;

    this->GetClusters(m_inputClusterListNameU, clustersU);

    this->GetClusters(m_inputClusterListNameV, clustersV);

    this->GetClusters(m_inputClusterListNameW, clustersW);


    PfoLengthMap pfoLengthMap;

    ParticleList initialParticleList, finalParticleList;

    this->ThreeViewMatching(clustersU, clustersV, clustersW, clusterLengthMap, pfoLengthMap, initialParticleList);

    this->OneViewMatching(clustersU, clusterLengthMap, pfoLengthMap, initialParticleList);

    this->OneViewMatching(clustersV, clusterLengthMap, pfoLengthMap, initialParticleList);

    this->OneViewMatching(clustersW, clusterLengthMap, pfoLengthMap, initialParticleList);

    this->SelectParticles(initialParticleList, clusterLengthMap, finalParticleList);

    this->CreateParticles(finalParticleList);

}


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


void DeltaRayMatchingAlgorithm::ThreeViewMatching(const ClusterVector &clusters1, const ClusterVector &clusters2,

    const ClusterVector &clusters3, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, ParticleList &particleList) const

{

    if (clusters1.empty() || clusters2.empty() || clusters3.empty())

        return;


    for (const Cluster *const pCluster1 : clusters1)

    {

        if (!pCluster1->IsAvailable())

            continue;


        for (const Cluster *const pCluster2 : clusters2)

        {

            if (!pCluster2->IsAvailable())

                continue;


            for (const Cluster *const pCluster3 : clusters3)

            {

                if (!pCluster3->IsAvailable())

                    continue;


                if (!this->AreClustersMatched(pCluster1, pCluster2, pCluster3))

                    continue;


                const ParticleFlowObject *pBestPfo = NULL;

                this->FindBestParentPfo(pCluster1, pCluster2, pCluster3, clusterLengthMap, pfoLengthMap, pBestPfo);


                // ATTN Need to record all matches when all three views are used

                particleList.push_back(Particle(pCluster1, pCluster2, pCluster3, pBestPfo));

            }

        }

    }

}


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


void DeltaRayMatchingAlgorithm::TwoViewMatching(const ClusterVector &clusters1, const ClusterVector &clusters2,

    ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, ParticleList &particleList) const

{

    if (clusters1.empty() || clusters2.empty())

        return;


    for (const Cluster *const pCluster1 : clusters1)

    {

        if (!pCluster1->IsAvailable())

            continue;


        for (const Cluster *const pCluster2 : clusters2)

        {

            if (!pCluster2->IsAvailable())

                continue;


            if (!this->AreClustersMatched(pCluster1, pCluster2, NULL))

                continue;


            const ParticleFlowObject *pBestPfo = NULL;

            this->FindBestParentPfo(pCluster1, pCluster2, NULL, clusterLengthMap, pfoLengthMap, pBestPfo);


            if (NULL == pBestPfo)

                continue;


            particleList.push_back(Particle(pCluster1, pCluster2, NULL, pBestPfo));

        }

    }

}


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


void DeltaRayMatchingAlgorithm::OneViewMatching(

    const ClusterVector &clusters, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, ParticleList &particleList) const

{

    if (clusters.empty())

        return;


    for (const Cluster *const pCluster : clusters)

    {

        if (!pCluster->IsAvailable())

            continue;


        const ParticleFlowObject *pBestPfo = NULL;

        this->FindBestParentPfo(pCluster, NULL, NULL, clusterLengthMap, pfoLengthMap, pBestPfo);


        if (NULL == pBestPfo)

            continue;


        particleList.push_back(Particle(pCluster, NULL, NULL, pBestPfo));

    }

}


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


void DeltaRayMatchingAlgorithm::SelectParticles(const ParticleList &initialParticles, ClusterLengthMap &clusterLengthMap, ParticleList &finalParticles) const

{

    for (const Particle &particle1 : initialParticles)

    {

        bool isGoodParticle(true);


        for (const Particle &particle2 : initialParticles)

        {

            const bool commonU(particle1.GetClusterU() == particle2.GetClusterU());

            const bool commonV(particle1.GetClusterV() == particle2.GetClusterV());

            const bool commonW(particle1.GetClusterW() == particle2.GetClusterW());


            const bool ambiguousU(commonU && NULL != particle1.GetClusterU());

            const bool ambiguousV(commonV && NULL != particle1.GetClusterV());

            const bool ambiguousW(commonW && NULL != particle1.GetClusterW());


            if (commonU && commonV && commonW)

                continue;


            if (ambiguousU || ambiguousV || ambiguousW)

            {

                if (particle2.GetNViews() > particle1.GetNViews())

                {

                    isGoodParticle = false;

                }

                else if (particle2.GetNViews() == particle1.GetNViews() && NULL != particle2.GetParentPfo())

                {

                    if ((NULL == particle1.GetParentPfo()) || (particle2.GetNCaloHits() > particle1.GetNCaloHits()) ||

                        (particle2.GetNCaloHits() == particle1.GetNCaloHits() &&

                            this->GetLength(particle2, clusterLengthMap) >= this->GetLength(particle1, clusterLengthMap)))

                    {

                        isGoodParticle = false;

                    }

                }


                if (!isGoodParticle)

                    break;

            }

        }


        if (isGoodParticle && NULL != particle1.GetParentPfo())

            finalParticles.push_back(particle1);

    }

}


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


void DeltaRayMatchingAlgorithm::CreateParticles(const ParticleList &particleList) const

{

    PfoVector parentVector, daughterVector;

    this->GetTrackPfos(m_parentPfoListName, parentVector);

    this->GetAllPfos(m_daughterPfoListName, daughterVector);


    PfoList parentList(parentVector.begin(), parentVector.end());

    PfoList daughterList(daughterVector.begin(), daughterVector.end());


    for (const Particle &particle : particleList)

    {

        const ParticleFlowObject *const pParentPfo = particle.GetParentPfo();


        if (NULL == pParentPfo)

            continue;


        const Cluster *const pClusterU = particle.GetClusterU();

        const Cluster *const pClusterV = particle.GetClusterV();

        const Cluster *const pClusterW = particle.GetClusterW();


        if (NULL == pClusterU && NULL == pClusterV && NULL == pClusterW)

            throw StatusCodeException(STATUS_CODE_FAILURE);


        ClusterList clusterList;


        if (pClusterU)

            clusterList.push_back(pClusterU);


        if (pClusterV)

            clusterList.push_back(pClusterV);


        if (pClusterW)

            clusterList.push_back(pClusterW);


        if (parentList.end() != std::find(parentList.begin(), parentList.end(), pParentPfo))

        {

            this->CreateDaughterPfo(clusterList, pParentPfo);

        }

        else if (daughterList.end() != std::find(daughterList.begin(), daughterList.end(), pParentPfo))

        {

            this->AddToDaughterPfo(clusterList, pParentPfo);

        }

        else

        {

            throw StatusCodeException(STATUS_CODE_FAILURE);

        }

    }

}


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


bool DeltaRayMatchingAlgorithm::AreClustersMatched(const Cluster *const pCluster1, const Cluster *const pCluster2, const Cluster *const pCluster3) const

{

    if (nullptr == pCluster1 && nullptr == pCluster2 && nullptr == pCluster3)

        throw StatusCodeException(STATUS_CODE_FAILURE);


    // First step: Check X overlap

    float xMin1(-std::numeric_limits<float>::max()), xMax1(+std::numeric_limits<float>::max());

    float xMin2(-std::numeric_limits<float>::max()), xMax2(+std::numeric_limits<float>::max());

    float xMin3(-std::numeric_limits<float>::max()), xMax3(+std::numeric_limits<float>::max());


    if (nullptr != pCluster1)

        pCluster1->GetClusterSpanX(xMin1, xMax1);


    if (nullptr != pCluster2)

        pCluster2->GetClusterSpanX(xMin2, xMax2);


    if (nullptr != pCluster3)

        pCluster3->GetClusterSpanX(xMin3, xMax3);


    const float xPitch(0.5 * m_xOverlapWindow);

    const float xMin(std::max(xMin1, std::max(xMin2, xMin3)) - xPitch);

    const float xMax(std::min(xMax1, std::min(xMax2, xMax3)) + xPitch);

    const float xOverlap(xMax - xMin);


    if (xOverlap < std::numeric_limits<float>::epsilon())

        return false;


    if (nullptr == pCluster1 || nullptr == pCluster2 || nullptr == pCluster3)

        return true;


    // Second step: Check 3D matching

    const HitType hitType1(LArClusterHelper::GetClusterHitType(pCluster1));

    const HitType hitType2(LArClusterHelper::GetClusterHitType(pCluster2));

    const HitType hitType3(LArClusterHelper::GetClusterHitType(pCluster3));


    if (hitType1 == hitType2 || hitType2 == hitType3 || hitType3 == hitType1)

        throw StatusCodeException(STATUS_CODE_FAILURE);


    const unsigned int nSamplingPoints(1 + static_cast<unsigned int>(xOverlap / xPitch));


    for (unsigned int n = 0; n < nSamplingPoints; ++n)

    {

        const float x(xMin + (xMax - xMin) * (static_cast<float>(n) + 0.5f) / static_cast<float>(nSamplingPoints));

        const float xmin(x - xPitch);

        const float xmax(x + xPitch);


        try

        {

            float zMin1(0.f), zMin2(0.f), zMin3(0.f), zMax1(0.f), zMax2(0.f), zMax3(0.f);

            pCluster1->GetClusterSpanZ(xmin, xmax, zMin1, zMax1);

            pCluster2->GetClusterSpanZ(xmin, xmax, zMin2, zMax2);

            pCluster3->GetClusterSpanZ(xmin, xmax, zMin3, zMax3);


            const float z1(0.5f * (zMin1 + zMax1));

            const float z2(0.5f * (zMin2 + zMax2));

            const float z3(0.5f * (zMin3 + zMax3));


            const float dz1(zMax1 - zMin1);

            const float dz2(zMax2 - zMin2);

            const float dz3(zMax3 - zMin3);

            const float dz4(LArGeometryHelper::GetWireZPitch(this->GetPandora()));


            const float zproj1(LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType2, hitType3, z2, z3));

            const float zproj2(LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType3, hitType1, z3, z1));

            const float zproj3(LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType1, hitType2, z1, z2));


            const float deltaSquared(((z1 - zproj1) * (z1 - zproj1) + (z2 - zproj2) * (z2 - zproj2) + (z3 - zproj3) * (z3 - zproj3)) / 3.f);

            const float sigmaSquared(dz1 * dz1 + dz2 * dz2 + dz3 * dz3 + dz4 * dz4);

            const float pseudoChi2(deltaSquared / sigmaSquared);


            if (pseudoChi2 < m_pseudoChi2Cut)

                return true;

        }

        catch (StatusCodeException &statusCodeException)

        {

            if (STATUS_CODE_NOT_FOUND != statusCodeException.GetStatusCode())

                throw statusCodeException;

        }

    }


    return false;

}


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


void DeltaRayMatchingAlgorithm::FindBestParentPfo(const Cluster *const pCluster1, const Cluster *const pCluster2,

    const Cluster *const pCluster3, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, const ParticleFlowObject *&pBestPfo) const

{

    PfoVector pfoVector;

    this->GetTrackPfos(m_parentPfoListName, pfoVector);

    this->GetAllPfos(m_daughterPfoListName, pfoVector);


    if (pfoVector.empty())

        throw StatusCodeException(STATUS_CODE_FAILURE);


    unsigned int numViews(0);

    float lengthSquared(0.f);


    if (pCluster1)

    {

        lengthSquared += this->GetLengthFromCache(pCluster1, clusterLengthMap);

        ++numViews;

    }


    if (pCluster2)

    {

        lengthSquared += this->GetLengthFromCache(pCluster2, clusterLengthMap);

        ++numViews;

    }


    if (pCluster3)

    {

        lengthSquared += this->GetLengthFromCache(pCluster3, clusterLengthMap);

        ++numViews;

    }


    float bestDistanceSquared(static_cast<float>(numViews) * m_distanceForMatching * m_distanceForMatching);


    for (const ParticleFlowObject *const pPfo : pfoVector)

    {

        if (lengthSquared > this->GetLengthFromCache(pPfo, pfoLengthMap))

            continue;


        try

        {

            float distanceSquared(0.f);


            if (NULL != pCluster1)

                distanceSquared += this->GetDistanceSquaredToPfo(pCluster1, pPfo);


            if (NULL != pCluster2)

                distanceSquared += this->GetDistanceSquaredToPfo(pCluster2, pPfo);


            if (NULL != pCluster3)

                distanceSquared += this->GetDistanceSquaredToPfo(pCluster3, pPfo);


            if (distanceSquared < bestDistanceSquared)

            {

                pBestPfo = pPfo;

                bestDistanceSquared = distanceSquared;

            }

        }

        catch (StatusCodeException &statusCodeException)

        {

            if (!(STATUS_CODE_NOT_FOUND == statusCodeException.GetStatusCode()))

                throw statusCodeException;

        }

    }

}


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


float DeltaRayMatchingAlgorithm::GetLengthFromCache(const Cluster *const pCluster, ClusterLengthMap &clusterLengthMap) const

{

    ClusterLengthMap::const_iterator iter = clusterLengthMap.find(pCluster);


    if (clusterLengthMap.end() != iter)

        return iter->second;


    const float lengthSquared(LArClusterHelper::GetLengthSquared(pCluster));

    (void)clusterLengthMap.insert(ClusterLengthMap::value_type(pCluster, lengthSquared));

    return lengthSquared;

}


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


float DeltaRayMatchingAlgorithm::GetLengthFromCache(const ParticleFlowObject *const pPfo, PfoLengthMap &pfoLengthMap) const

{

    PfoLengthMap::const_iterator iter = pfoLengthMap.find(pPfo);


    if (pfoLengthMap.end() != iter)

        return iter->second;


    const float lengthSquared(LArPfoHelper::GetTwoDLengthSquared(pPfo));

    (void)pfoLengthMap.insert(PfoLengthMap::value_type(pPfo, lengthSquared));

    return lengthSquared;

}


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


float DeltaRayMatchingAlgorithm::GetLength(const Particle &particle, ClusterLengthMap &clusterLengthMap) const

{

    float lengthSquared(0.f);


    if (particle.GetClusterU())

        lengthSquared += this->GetLengthFromCache(particle.GetClusterU(), clusterLengthMap);


    if (particle.GetClusterV())

        lengthSquared += this->GetLengthFromCache(particle.GetClusterV(), clusterLengthMap);


    if (particle.GetClusterW())

        lengthSquared += this->GetLengthFromCache(particle.GetClusterW(), clusterLengthMap);


    return lengthSquared;

}


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


float DeltaRayMatchingAlgorithm::GetDistanceSquaredToPfo(const Cluster *const pCluster, const ParticleFlowObject *const pPfo) const

{

    const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));


    if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))

        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);


    ClusterList comparisonList;

    const ClusterToClustersMap &nearbyClusters((TPC_VIEW_U == hitType) ? m_nearbyClustersU : (TPC_VIEW_V == hitType) ? m_nearbyClustersV : m_nearbyClustersW);


    if (!nearbyClusters.count(pCluster))

        return std::numeric_limits<float>::max();


    ClusterList pfoClusterList;

    LArPfoHelper::GetClusters(pPfo, hitType, pfoClusterList);


    for (const Cluster *const pPfoCluster : pfoClusterList)

    {

        const ClusterList &clusterList(nearbyClusters.at(pCluster));


        if ((clusterList.end() != std::find(clusterList.begin(), clusterList.end(), pPfoCluster)) &&

            (comparisonList.end() == std::find(comparisonList.begin(), comparisonList.end(), pPfoCluster)))

        {

            comparisonList.push_back(pPfoCluster);

        }

    }


    if (comparisonList.empty())

        return std::numeric_limits<float>::max();


    return LArClusterHelper::GetClosestDistance(pCluster, comparisonList);

}


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


void DeltaRayMatchingAlgorithm::CreateDaughterPfo(const ClusterList &clusterList, const ParticleFlowObject *const pParentPfo) const

{

    const PfoList *pPfoList = NULL;

    std::string pfoListName;

    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pPfoList, pfoListName));


    // TODO Correct these placeholder parameters

    PandoraContentApi::ParticleFlowObject::Parameters pfoParameters;

    pfoParameters.m_particleId = E_MINUS; // SHOWER

    pfoParameters.m_charge = PdgTable::GetParticleCharge(pfoParameters.m_particleId.Get());

    pfoParameters.m_mass = PdgTable::GetParticleMass(pfoParameters.m_particleId.Get());

    pfoParameters.m_energy = 0.f;

    pfoParameters.m_momentum = CartesianVector(0.f, 0.f, 0.f);

    pfoParameters.m_clusterList = clusterList;


    const ParticleFlowObject *pDaughterPfo(NULL);

    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::Create(*this, pfoParameters, pDaughterPfo));


    if (!pPfoList->empty())

    {

        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Pfo>(*this, m_daughterPfoListName));

        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*this, pParentPfo, pDaughterPfo));

    }

}


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


void DeltaRayMatchingAlgorithm::AddToDaughterPfo(const ClusterList &clusterList, const ParticleFlowObject *const pParentPfo) const

{

    for (const Cluster *const pDaughterCluster : clusterList)

    {

        const HitType hitType(LArClusterHelper::GetClusterHitType(pDaughterCluster));

        const std::string clusterListName(

            (TPC_VIEW_U == hitType) ? m_inputClusterListNameU : (TPC_VIEW_V == hitType) ? m_inputClusterListNameV : m_inputClusterListNameW);


        ClusterList pfoClusters;

        LArPfoHelper::GetClusters(pParentPfo, hitType, pfoClusters);


        if (pfoClusters.empty())

            throw StatusCodeException(STATUS_CODE_FAILURE);


        const Cluster *const pParentCluster = *(pfoClusters.begin());


        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,

            PandoraContentApi::MergeAndDeleteClusters(*this, pParentCluster, pDaughterCluster, clusterListName, clusterListName));

    }

}


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

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


DeltaRayMatchingAlgorithm::Particle::Particle(

    const Cluster *const pCluster1, const Cluster *const pCluster2, const Cluster *const pCluster3, const ParticleFlowObject *const pPfo) :

    m_pClusterU(NULL),

    m_pClusterV(NULL),

    m_pClusterW(NULL),

    m_pParentPfo(NULL)

{

    const HitType hitType1(NULL != pCluster1 ? LArClusterHelper::GetClusterHitType(pCluster1) : HIT_CUSTOM);

    const HitType hitType2(NULL != pCluster2 ? LArClusterHelper::GetClusterHitType(pCluster2) : HIT_CUSTOM);

    const HitType hitType3(NULL != pCluster3 ? LArClusterHelper::GetClusterHitType(pCluster3) : HIT_CUSTOM);


    m_pClusterU = ((TPC_VIEW_U == hitType1) ? pCluster1 : (TPC_VIEW_U == hitType2) ? pCluster2 : (TPC_VIEW_U == hitType3) ? pCluster3 : NULL);

    m_pClusterV = ((TPC_VIEW_V == hitType1) ? pCluster1 : (TPC_VIEW_V == hitType2) ? pCluster2 : (TPC_VIEW_V == hitType3) ? pCluster3 : NULL);

    m_pClusterW = ((TPC_VIEW_W == hitType1) ? pCluster1 : (TPC_VIEW_W == hitType2) ? pCluster2 : (TPC_VIEW_W == hitType3) ? pCluster3 : NULL);

    m_pParentPfo = pPfo;


    if (NULL == m_pClusterU && NULL == m_pClusterV && NULL == m_pClusterW)

        throw StatusCodeException(STATUS_CODE_FAILURE);

}


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


unsigned int DeltaRayMatchingAlgorithm::Particle::GetNViews() const

{

    unsigned int numViews(0);


    if (NULL != m_pClusterU)

        numViews += 1;


    if (NULL != m_pClusterV)

        numViews += 1;


    if (NULL != m_pClusterW)

        numViews += 1;


    return numViews;

}


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


unsigned int DeltaRayMatchingAlgorithm::Particle::GetNCaloHits() const

{

    unsigned int numCaloHits(0);


    if (NULL != m_pClusterU)

        numCaloHits += m_pClusterU->GetNCaloHits();


    if (NULL != m_pClusterV)

        numCaloHits += m_pClusterV->GetNCaloHits();


    if (NULL != m_pClusterW)

        numCaloHits += m_pClusterW->GetNCaloHits();


    return numCaloHits;

}


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

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


StatusCode DeltaRayMatchingAlgorithm::ReadSettings(const TiXmlHandle xmlHandle)

{

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "ParentPfoListName", m_parentPfoListName));

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "DaughterPfoListName", m_daughterPfoListName));

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputClusterListNameU", m_inputClusterListNameU));

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputClusterListNameV", m_inputClusterListNameV));

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputClusterListNameW", m_inputClusterListNameW));


    PANDORA_RETURN_RESULT_IF_AND_IF(

        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCaloHitsPerCluster", m_minCaloHitsPerCluster));


    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "OverlapWindow", m_xOverlapWindow));


    PANDORA_RETURN_RESULT_IF_AND_IF(

        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DistanceForMatching", m_distanceForMatching));


    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PseudoChi2Cut", m_pseudoChi2Cut));


    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SearchRegion1D", m_searchRegion1D));


    return STATUS_CODE_SUCCESS;

}


} // namespace lar_content

AlgorithmHeaders.h
Grouping of header files for many classes of use in particle flow algorithms.

DeltaRayMatchingAlgorithm.h
Header file for the delta ray matching algorithm class.

KDTreeLinkerAlgoT.h
Header file for the kd tree linker algo template class.

LArClusterHelper.h
Header file for the cluster helper class.

LArGeometryHelper.h
Header file for the geometry helper class.

LArPfoHelper.h
Header file for the pfo helper class.

PANDORA_THROW_RESULT_IF_AND_IF
#define PANDORA_THROW_RESULT_IF_AND_IF(StatusCode1, StatusCode2, Operator, Command)
Definition StatusCodes.h:55

PANDORA_THROW_RESULT_IF
#define PANDORA_THROW_RESULT_IF(StatusCode1, Operator, Command)
Definition StatusCodes.h:43

PANDORA_RETURN_RESULT_IF_AND_IF
#define PANDORA_RETURN_RESULT_IF_AND_IF(StatusCode1, StatusCode2, Operator, Command)
Definition StatusCodes.h:31

PANDORA_RETURN_RESULT_IF
#define PANDORA_RETURN_RESULT_IF(StatusCode1, Operator, Command)
Definition StatusCodes.h:19

PandoraContentApi::ReplaceCurrentList
static pandora::StatusCode ReplaceCurrentList(const pandora::Algorithm &algorithm, const std::string &newListName)
Replace the current list with a pre-saved list; use this new list as a permanent replacement for the ...
Definition PandoraContentApi.cc:100

PandoraContentApi::CreateTemporaryListAndSetCurrent
static pandora::StatusCode CreateTemporaryListAndSetCurrent(const pandora::Algorithm &algorithm, const T *&pT, std::string &temporaryListName)
Create a temporary list and set it to be the current list, enabling object creation.
Definition PandoraContentApi.cc:182

PandoraContentApi::MergeAndDeleteClusters
static pandora::StatusCode MergeAndDeleteClusters(const pandora::Algorithm &algorithm, const pandora::Cluster *const pClusterToEnlarge, const pandora::Cluster *const pClusterToDelete)
Merge two clusters in the current list, enlarging one cluster and deleting the second.
Definition PandoraContentApi.cc:301

PandoraContentApi::SetPfoParentDaughterRelationship
static pandora::StatusCode SetPfoParentDaughterRelationship(const pandora::Algorithm &algorithm, const pandora::ParticleFlowObject *const pParentPfo, const pandora::ParticleFlowObject *const pDaughterPfo)
Set parent-daughter particle flow object relationship.
Definition PandoraContentApi.cc:333

PandoraContentApi::GetList
static pandora::StatusCode GetList(const pandora::Algorithm &algorithm, const std::string &listName, const T *&pT)
Get a named list.
Definition PandoraContentApi.cc:116

PandoraContentApi::GetSettings
static const pandora::PandoraSettings * GetSettings(const pandora::Algorithm &algorithm)
Get the pandora settings instance.
Definition PandoraContentApi.cc:15

lar_content::DeltaRayMatchingAlgorithm::Particle
Particle class.
Definition DeltaRayMatchingAlgorithm.h:43

lar_content::DeltaRayMatchingAlgorithm::Particle::m_pParentPfo
const pandora::ParticleFlowObject * m_pParentPfo
Address of parent Pfo.
Definition DeltaRayMatchingAlgorithm.h:90

lar_content::DeltaRayMatchingAlgorithm::Particle::m_pClusterV
const pandora::Cluster * m_pClusterV
Address of cluster in V view.
Definition DeltaRayMatchingAlgorithm.h:88

lar_content::DeltaRayMatchingAlgorithm::Particle::GetNCaloHits
unsigned int GetNCaloHits() const
Get number of calo hits.
Definition DeltaRayMatchingAlgorithm.cc:760

lar_content::DeltaRayMatchingAlgorithm::Particle::m_pClusterU
const pandora::Cluster * m_pClusterU
Address of cluster in U view.
Definition DeltaRayMatchingAlgorithm.h:87

lar_content::DeltaRayMatchingAlgorithm::Particle::GetClusterV
const pandora::Cluster * GetClusterV() const
Get cluster in V view.
Definition DeltaRayMatchingAlgorithm.h:326

lar_content::DeltaRayMatchingAlgorithm::Particle::GetNViews
unsigned int GetNViews() const
Get number of views.
Definition DeltaRayMatchingAlgorithm.cc:742

lar_content::DeltaRayMatchingAlgorithm::Particle::Particle
Particle(const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2, const pandora::Cluster *const pCluster3, const pandora::ParticleFlowObject *const pPfo)
Constructor.
Definition DeltaRayMatchingAlgorithm.cc:720

lar_content::DeltaRayMatchingAlgorithm::Particle::GetClusterW
const pandora::Cluster * GetClusterW() const
Get cluster in W view.
Definition DeltaRayMatchingAlgorithm.h:332

lar_content::DeltaRayMatchingAlgorithm::Particle::GetClusterU
const pandora::Cluster * GetClusterU() const
Get cluster in U view.
Definition DeltaRayMatchingAlgorithm.h:320

lar_content::DeltaRayMatchingAlgorithm::Particle::m_pClusterW
const pandora::Cluster * m_pClusterW
Address of cluster in W view.
Definition DeltaRayMatchingAlgorithm.h:89

lar_content::DeltaRayMatchingAlgorithm::HitToClusterMap
std::unordered_map< const pandora::CaloHit *, const pandora::Cluster * > HitToClusterMap
Definition DeltaRayMatchingAlgorithm.h:100

lar_content::DeltaRayMatchingAlgorithm::m_inputClusterListNameW
std::string m_inputClusterListNameW
The input cluster list name for the w view.
Definition DeltaRayMatchingAlgorithm.h:304

lar_content::DeltaRayMatchingAlgorithm::m_searchRegion1D
float m_searchRegion1D
Search region, applied to each dimension, for look-up from kd-trees.
Definition DeltaRayMatchingAlgorithm.h:311

lar_content::DeltaRayMatchingAlgorithm::ClusterLengthMap
std::unordered_map< const pandora::Cluster *, float > ClusterLengthMap
Definition DeltaRayMatchingAlgorithm.h:145

lar_content::DeltaRayMatchingAlgorithm::OneViewMatching
void OneViewMatching(ClusterLengthMap &clusterLengthMap) const
Match clusters using single views.
Definition DeltaRayMatchingAlgorithm.cc:228

lar_content::DeltaRayMatchingAlgorithm::m_nearbyClustersV
ClusterToClustersMap m_nearbyClustersV
The nearby clusters map for the v view.
Definition DeltaRayMatchingAlgorithm.h:313

lar_content::DeltaRayMatchingAlgorithm::CreateDaughterPfo
void CreateDaughterPfo(const pandora::ClusterList &clusterList, const pandora::ParticleFlowObject *const pParentPfo) const
Create a new Pfo from an input cluster list and set up a parent/daughter relationship.
Definition DeltaRayMatchingAlgorithm.cc:669

lar_content::DeltaRayMatchingAlgorithm::CreateParticles
void CreateParticles(const ParticleList &particleList) const
Build new particle flow objects.
Definition DeltaRayMatchingAlgorithm.cc:385

lar_content::DeltaRayMatchingAlgorithm::m_distanceForMatching
float m_distanceForMatching
The maximum allowed distance between tracks and delta rays.
Definition DeltaRayMatchingAlgorithm.h:308

lar_content::DeltaRayMatchingAlgorithm::InitializeNearbyClusterMaps
void InitializeNearbyClusterMaps()
Initialize nearby cluster maps.
Definition DeltaRayMatchingAlgorithm.cc:62

lar_content::DeltaRayMatchingAlgorithm::DeltaRayMatchingAlgorithm
DeltaRayMatchingAlgorithm()
Default constructor.
Definition DeltaRayMatchingAlgorithm.cc:24

lar_content::DeltaRayMatchingAlgorithm::Run
pandora::StatusCode Run()
Run the algorithm.
Definition DeltaRayMatchingAlgorithm.cc:35

lar_content::DeltaRayMatchingAlgorithm::ThreeViewMatching
void ThreeViewMatching(ClusterLengthMap &clusterLengthMap) const
Match clusters using all three views.
Definition DeltaRayMatchingAlgorithm.cc:194

lar_content::DeltaRayMatchingAlgorithm::m_inputClusterListNameV
std::string m_inputClusterListNameV
The input cluster list name for the v view.
Definition DeltaRayMatchingAlgorithm.h:303

lar_content::DeltaRayMatchingAlgorithm::m_parentPfoListName
std::string m_parentPfoListName
The parent pfo list name.
Definition DeltaRayMatchingAlgorithm.h:299

lar_content::DeltaRayMatchingAlgorithm::SelectParticles
void SelectParticles(const ParticleList &inputParticles, ClusterLengthMap &clusterLengthMap, ParticleList &outputParticles) const
Resolve any ambiguities between candidate particles.
Definition DeltaRayMatchingAlgorithm.cc:338

lar_content::DeltaRayMatchingAlgorithm::m_xOverlapWindow
float m_xOverlapWindow
The maximum allowed displacement in x position.
Definition DeltaRayMatchingAlgorithm.h:307

lar_content::DeltaRayMatchingAlgorithm::AreClustersMatched
bool AreClustersMatched(const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2, const pandora::Cluster *const pCluster3) const
Look at consistency of a combination of clusters.
Definition DeltaRayMatchingAlgorithm.cc:436

lar_content::DeltaRayMatchingAlgorithm::HitKDNode2DList
std::vector< HitKDNode2D > HitKDNode2DList
Definition DeltaRayMatchingAlgorithm.h:97

lar_content::DeltaRayMatchingAlgorithm::m_nearbyClustersW
ClusterToClustersMap m_nearbyClustersW
The nearby clusters map for the w view.
Definition DeltaRayMatchingAlgorithm.h:314

lar_content::DeltaRayMatchingAlgorithm::InitializeNearbyClusterMap
void InitializeNearbyClusterMap(const std::string &clusterListName, ClusterToClustersMap &nearbyClusters)
Initialize a nearby cluster map with details relating to a specific cluster list.
Definition DeltaRayMatchingAlgorithm.cc:72

lar_content::DeltaRayMatchingAlgorithm::ClearNearbyClusterMaps
void ClearNearbyClusterMaps()
Clear nearby cluster maps.
Definition DeltaRayMatchingAlgorithm.cc:125

lar_content::DeltaRayMatchingAlgorithm::m_pseudoChi2Cut
float m_pseudoChi2Cut
Pseudo chi2 cut for three view matching.
Definition DeltaRayMatchingAlgorithm.h:309

lar_content::DeltaRayMatchingAlgorithm::m_inputClusterListNameU
std::string m_inputClusterListNameU
The input cluster list name for the u view.
Definition DeltaRayMatchingAlgorithm.h:302

lar_content::DeltaRayMatchingAlgorithm::FindBestParentPfo
void FindBestParentPfo(const pandora::Cluster *const pClusterU, const pandora::Cluster *const pClusterV, const pandora::Cluster *const pClusterW, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, const pandora::ParticleFlowObject *&pBestPfo) const
Find best Pfo to associate a UVW triplet.
Definition DeltaRayMatchingAlgorithm.cc:521

lar_content::DeltaRayMatchingAlgorithm::m_daughterPfoListName
std::string m_daughterPfoListName
The daughter pfo list name for new daughter particles.
Definition DeltaRayMatchingAlgorithm.h:300

lar_content::DeltaRayMatchingAlgorithm::m_minCaloHitsPerCluster
unsigned int m_minCaloHitsPerCluster
The min number of calo hits per candidate cluster.
Definition DeltaRayMatchingAlgorithm.h:306

lar_content::DeltaRayMatchingAlgorithm::PfoLengthMap
std::unordered_map< const pandora::ParticleFlowObject *, float > PfoLengthMap
Definition DeltaRayMatchingAlgorithm.h:146

lar_content::DeltaRayMatchingAlgorithm::AddToDaughterPfo
void AddToDaughterPfo(const pandora::ClusterList &clusterList, const pandora::ParticleFlowObject *const pParentPfo) const
Merge an input cluster list with an existing daughter Pfo.
Definition DeltaRayMatchingAlgorithm.cc:696

lar_content::DeltaRayMatchingAlgorithm::ClusterToClustersMap
std::unordered_map< const pandora::Cluster *, pandora::ClusterList > ClusterToClustersMap
Definition DeltaRayMatchingAlgorithm.h:99

lar_content::DeltaRayMatchingAlgorithm::GetAllPfos
void GetAllPfos(const std::string &inputPfoListName, pandora::PfoVector &pfoVector) const
Get a vector of all Pfos in the provided input Pfo lists.
Definition DeltaRayMatchingAlgorithm.cc:134

lar_content::DeltaRayMatchingAlgorithm::GetLength
float GetLength(const Particle &particle, ClusterLengthMap &clusterLengthMap) const
Get the length (squared) of a candidate particle.
Definition DeltaRayMatchingAlgorithm.cc:616

lar_content::DeltaRayMatchingAlgorithm::ReadSettings
pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
Read the algorithm settings.
Definition DeltaRayMatchingAlgorithm.cc:779

lar_content::DeltaRayMatchingAlgorithm::GetLengthFromCache
float GetLengthFromCache(const pandora::Cluster *const pCluster, ClusterLengthMap &clusterLengthMap) const
Reduce number of length (squared) calculations by caching results when they are first obtained.
Definition DeltaRayMatchingAlgorithm.cc:588

lar_content::DeltaRayMatchingAlgorithm::GetTrackPfos
void GetTrackPfos(const std::string &inputPfoListName, pandora::PfoVector &pfoVector) const
Get a vector of track-like Pfos in the provided input Pfo lists.
Definition DeltaRayMatchingAlgorithm.cc:150

lar_content::DeltaRayMatchingAlgorithm::TwoViewMatching
void TwoViewMatching(ClusterLengthMap &clusterLengthMap) const
Match clusters using pairs of views.
Definition DeltaRayMatchingAlgorithm.cc:210

lar_content::DeltaRayMatchingAlgorithm::ParticleList
std::vector< Particle > ParticleList
Definition DeltaRayMatchingAlgorithm.h:93

lar_content::DeltaRayMatchingAlgorithm::m_nearbyClustersU
ClusterToClustersMap m_nearbyClustersU
The nearby clusters map for the u view.
Definition DeltaRayMatchingAlgorithm.h:312

lar_content::DeltaRayMatchingAlgorithm::GetClusters
void GetClusters(const std::string &clusterListName, pandora::ClusterVector &clusterVector) const
Get a vector containing all available input clusters in the provided cluster list,...
Definition DeltaRayMatchingAlgorithm.cc:170

lar_content::DeltaRayMatchingAlgorithm::GetDistanceSquaredToPfo
float GetDistanceSquaredToPfo(const pandora::Cluster *const pCluster, const pandora::ParticleFlowObject *const pPfo) const
Get displacementr between cluster and particle flow object.
Definition DeltaRayMatchingAlgorithm.cc:634

lar_content::KDTreeBoxT
Box structure used to define 2D field. It's used in KDTree building step to divide the detector space...
Definition KDTreeLinkerToolsT.h:37

lar_content::KDTreeLinkerAlgo< const pandora::CaloHit *, 2 >

lar_content::KDTreeLinkerAlgo::build
void build(std::vector< KDTreeNodeInfoT< DATA, DIM > > &eltList, const KDTreeBoxT< DIM > &region)
Build the KD tree from the "eltList" in the space define by "region".
Definition KDTreeLinkerAlgoT.h:183

lar_content::KDTreeLinkerAlgo::search
void search(const KDTreeBoxT< DIM > &searchBox, std::vector< KDTreeNodeInfoT< DATA, DIM > > &resRecHitList)
Search in the KDTree for all points that would be contained in the given searchbox The founded points...
Definition KDTreeLinkerAlgoT.h:249

lar_content::LArClusterHelper::GetClusterHitType
static pandora::HitType GetClusterHitType(const pandora::Cluster *const pCluster)
Get the hit type associated with a two dimensional cluster.
Definition LArClusterHelper.cc:21

lar_content::LArClusterHelper::SortByNHits
static bool SortByNHits(const pandora::Cluster *const pLhs, const pandora::Cluster *const pRhs)
Sort clusters by number of hits, then layer span, then inner layer, then position,...
Definition LArClusterHelper.cc:656

lar_content::LArClusterHelper::GetLengthSquared
static float GetLengthSquared(const pandora::Cluster *const pCluster)
Get length squared of cluster.
Definition LArClusterHelper.cc:65

lar_content::LArClusterHelper::GetClosestDistance
static float GetClosestDistance(const pandora::ClusterList &clusterList1, const pandora::ClusterList &clusterList2)
Get closest distance between clusters in a pair of cluster lists.
Definition LArClusterHelper.cc:146

lar_content::LArGeometryHelper::MergeTwoPositions
static float MergeTwoPositions(const pandora::Pandora &pandora, const pandora::HitType view1, const pandora::HitType view2, const float position1, const float position2)
Merge two views (U,V) to give a third view (Z).
Definition LArGeometryHelper.cc:31

lar_content::LArGeometryHelper::GetWireZPitch
static float GetWireZPitch(const pandora::Pandora &pandora, const float maxWirePitchDiscrepancy=0.01)
Return the wire pitch.
Definition LArGeometryHelper.h:273

lar_content::LArPfoHelper::IsTrack
static bool IsTrack(const pandora::ParticleFlowObject *const pPfo)
Return track flag based on Pfo Particle ID.
Definition LArPfoHelper.cc:344

lar_content::LArPfoHelper::SortByNHits
static bool SortByNHits(const pandora::ParticleFlowObject *const pLhs, const pandora::ParticleFlowObject *const pRhs)
Sort pfos by number of constituent hits.
Definition LArPfoHelper.cc:610

lar_content::LArPfoHelper::GetClusters
static void GetClusters(const pandora::PfoList &pfoList, const pandora::HitType &hitType, pandora::ClusterList &clusterList)
Get a list of clusters of a particular hit type from a list of pfos.
Definition LArPfoHelper.cc:88

lar_content::LArPfoHelper::GetTwoDLengthSquared
static float GetTwoDLengthSquared(const pandora::ParticleFlowObject *const pPfo)
Calculate length of Pfo using 2D clusters.
Definition LArPfoHelper.cc:238

pandora::CaloHit
CaloHit class.
Definition CaloHit.h:26

pandora::CartesianVector
CartesianVector class.
Definition CartesianVector.h:24

pandora::Cluster
Cluster class.
Definition Cluster.h:31

pandora::Cluster::IsAvailable
bool IsAvailable() const
Whether the cluster is available to be added to a particle flow object.
Definition Cluster.h:582

pandora::Cluster::GetNCaloHits
unsigned int GetNCaloHits() const
Get the number of calo hits in the cluster.
Definition Cluster.h:484

pandora::Cluster::GetClusterSpanX
void GetClusterSpanX(float &xmin, float &xmax) const
Get minimum and maximum X positions of the calo hits in this cluster.
Definition Cluster.cc:169

pandora::Cluster::GetClusterSpanZ
void GetClusterSpanZ(const float xmin, const float xmax, float &zmin, float &zmax) const
Get upper and lower Z positions of the calo hits in a cluster in range xmin to xmax.
Definition Cluster.cc:198

pandora::PandoraSettings::ShouldDisplayAlgorithmInfo
bool ShouldDisplayAlgorithmInfo() const
Whether to display algorithm information during processing.
Definition PandoraSettings.h:160

pandora::ParticleFlowObject
ParticleFlowObject class.
Definition ParticleFlowObject.h:26

pandora::PdgTable::GetParticleMass
static float GetParticleMass(const int pdgCode)
Get the mass of a particle type.
Definition PdgTable.h:205

pandora::PdgTable::GetParticleCharge
static int GetParticleCharge(const int pdgCode)
Get the charge of a particle type.
Definition PdgTable.h:227

pandora::Process::GetPandora
const Pandora & GetPandora() const
Get the associated pandora instance.
Definition Process.h:116

pandora::StatusCodeException
StatusCodeException class.
Definition StatusCodes.h:119

pandora::StatusCodeException::GetStatusCode
StatusCode GetStatusCode() const
Get status code.
Definition StatusCodes.h:191

pandora::TiXmlHandle
Definition tinyxml.h:1646

pandora::XmlHelper::ReadValue
static StatusCode ReadValue(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, T &t)
Read a value from an xml element.
Definition XmlHelper.h:136

lar_content
Definition CheatingBeamParticleIdTool.cc:19

lar_content::fill_and_bound_2d_kd_tree
KDTreeBox fill_and_bound_2d_kd_tree(const MANAGED_CONTAINER< const T * > &points, std::vector< KDTreeNodeInfoT< const T *, 2 > > &nodes)
fill_and_bound_2d_kd_tree
Definition KDTreeLinkerToolsT.h:309

lar_content::build_2d_kd_search_region
KDTreeBox build_2d_kd_search_region(const pandora::CaloHit *const point, const float x_span, const float z_span)
build_2d_kd_search_region
Definition KDTreeLinkerToolsT.cc:21

pandora
Definition LArContent.h:12

pandora::HitType
HitType
Calorimeter hit type enum.
Definition PandoraEnumeratedTypes.h:65

pandora::TPC_VIEW_V
@ TPC_VIEW_V
Definition PandoraEnumeratedTypes.h:71

pandora::HIT_CUSTOM
@ HIT_CUSTOM
Definition PandoraEnumeratedTypes.h:74

pandora::TPC_VIEW_U
@ TPC_VIEW_U
Definition PandoraEnumeratedTypes.h:70

pandora::TPC_VIEW_W
@ TPC_VIEW_W
Definition PandoraEnumeratedTypes.h:72

pandora::ClusterVector
std::vector< const Cluster * > ClusterVector
Definition PandoraInternal.h:445

pandora::ClusterList
MANAGED_CONTAINER< const Cluster * > ClusterList
Definition PandoraInternal.h:434

pandora::PfoVector
std::vector< const ParticleFlowObject * > PfoVector
Definition PandoraInternal.h:450

pandora::CaloHitList
MANAGED_CONTAINER< const CaloHit * > CaloHitList
Definition PandoraInternal.h:433

pandora::StatusCode
StatusCode
The StatusCode enum.
Definition StatusCodes.h:100

pandora::PfoList
MANAGED_CONTAINER< const ParticleFlowObject * > PfoList
Definition PandoraInternal.h:439