lar_content::DeltaRayMatchingAlgorithm Class Reference

DeltaRayMatchingAlgorithm class. More...

#include <DeltaRayMatchingAlgorithm.h>

Inheritance diagram for lar_content::DeltaRayMatchingAlgorithm:

Classes
class	Particle
	Particle class. More...

Public Member Functions
	DeltaRayMatchingAlgorithm ()
	Default constructor. More...

Private Types
typedef std::vector< Particle >	ParticleList
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::ClusterList >	ClusterToClustersMap
typedef std::unordered_map< const pandora::CaloHit *, const pandora::Cluster * >	HitToClusterMap
typedef std::unordered_map< const pandora::Cluster *, float >	ClusterLengthMap
typedef std::unordered_map< const pandora::ParticleFlowObject *, float >	PfoLengthMap

Private Member Functions
pandora::StatusCode	Run ()
void	InitializeNearbyClusterMaps ()
	Initialize nearby cluster maps. More...
void	InitializeNearbyClusterMap (const std::string &clusterListName, ClusterToClustersMap &nearbyClusters)
	Initialize a nearby cluster map with details relating to a specific cluster list. More...
void	ClearNearbyClusterMaps ()
	Clear nearby cluster maps. More...
void	GetAllPfos (const std::string &inputPfoListName, pandora::PfoVector &pfoVector) const
	Get a vector of all Pfos in the provided input Pfo lists. More...
void	GetTrackPfos (const std::string &inputPfoListName, pandora::PfoVector &pfoVector) const
	Get a vector of track-like Pfos in the provided input Pfo lists. More...
void	GetClusters (const std::string &clusterListName, pandora::ClusterVector &clusterVector) const
	Get a vector containing all available input clusters in the provided cluster list, storing sliding linear fits in the algorithm cache. More...
void	ThreeViewMatching (ClusterLengthMap &clusterLengthMap) const
	Match clusters using all three views. More...
void	TwoViewMatching (ClusterLengthMap &clusterLengthMap) const
	Match clusters using pairs of views. More...
void	OneViewMatching (ClusterLengthMap &clusterLengthMap) const
	Match clusters using single views. More...
void	ThreeViewMatching (const pandora::ClusterVector &clusters1, const pandora::ClusterVector &clusters2, const pandora::ClusterVector &clusters3, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, ParticleList &particleList) const
	Match clusters using all three views. More...
void	TwoViewMatching (const pandora::ClusterVector &clusters1, const pandora::ClusterVector &clusters2, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, ParticleList &particleList) const
	Match clusters using a pair of views. More...
void	OneViewMatching (const pandora::ClusterVector &clusters, ClusterLengthMap &clusterLengthMap, PfoLengthMap &pfoLengthMap, ParticleList &particleList) const
	Match clusters using a single view. More...
void	SelectParticles (const ParticleList &inputParticles, ClusterLengthMap &clusterLengthMap, ParticleList &outputParticles) const
	Resolve any ambiguities between candidate particles. More...
void	CreateParticles (const ParticleList &particleList) const
	Build new particle flow objects. More...
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. More...
float	GetLengthFromCache (const pandora::Cluster *const pCluster, ClusterLengthMap &clusterLengthMap) const
	Reduce number of length (squared) calculations by caching results when they are first obtained. More...
float	GetLengthFromCache (const pandora::ParticleFlowObject *const pPfo, PfoLengthMap &pfoLengthMap) const
	Reduce number of length (squared) calculations by caching results when they are first obtained. More...
float	GetLength (const Particle &particle, ClusterLengthMap &clusterLengthMap) const
	Get the length (squared) of a candidate particle. More...
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. More...
float	GetDistanceSquaredToPfo (const pandora::Cluster *const pCluster, const pandora::ParticleFlowObject *const pPfo) const
	Get displacementr between cluster and particle flow object. More...
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. More...
void	AddToDaughterPfo (const pandora::ClusterList &clusterList, const pandora::ParticleFlowObject *const pParentPfo) const
	Merge an input cluster list with an existing daughter Pfo. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Private Attributes
std::string	m_parentPfoListName
	The parent pfo list name. More...
std::string	m_daughterPfoListName
	The daughter pfo list name for new daughter particles. More...
std::string	m_inputClusterListNameU
	The input cluster list name for the u view. More...
std::string	m_inputClusterListNameV
	The input cluster list name for the v view. More...
std::string	m_inputClusterListNameW
	The input cluster list name for the w view. More...
unsigned int	m_minCaloHitsPerCluster
	The min number of calo hits per candidate cluster. More...
float	m_xOverlapWindow
	The maximum allowed displacement in x position. More...
float	m_distanceForMatching
	The maximum allowed distance between tracks and delta rays. More...
float	m_pseudoChi2Cut
	Pseudo chi2 cut for three view matching. More...
float	m_searchRegion1D
	Search region, applied to each dimension, for look-up from kd-trees. More...
ClusterToClustersMap	m_nearbyClustersU
	The nearby clusters map for the u view. More...
ClusterToClustersMap	m_nearbyClustersV
	The nearby clusters map for the v view. More...
ClusterToClustersMap	m_nearbyClustersW
	The nearby clusters map for the w view. More...

Detailed Description

DeltaRayMatchingAlgorithm class.

Definition at line 28 of file DeltaRayMatchingAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, float> lar_content::DeltaRayMatchingAlgorithm::ClusterLengthMap

private

Definition at line 145 of file DeltaRayMatchingAlgorithm.h.

typedef std::unordered_map<const pandora::Cluster *, pandora::ClusterList> lar_content::DeltaRayMatchingAlgorithm::ClusterToClustersMap

private

Definition at line 99 of file DeltaRayMatchingAlgorithm.h.

typedef KDTreeNodeInfoT<const pandora::CaloHit *, 2> lar_content::DeltaRayMatchingAlgorithm::HitKDNode2D

private

Definition at line 96 of file DeltaRayMatchingAlgorithm.h.

typedef std::vector<HitKDNode2D> lar_content::DeltaRayMatchingAlgorithm::HitKDNode2DList

private

Definition at line 97 of file DeltaRayMatchingAlgorithm.h.

typedef KDTreeLinkerAlgo<const pandora::CaloHit *, 2> lar_content::DeltaRayMatchingAlgorithm::HitKDTree2D

private

Definition at line 95 of file DeltaRayMatchingAlgorithm.h.

typedef std::unordered_map<const pandora::CaloHit *, const pandora::Cluster *> lar_content::DeltaRayMatchingAlgorithm::HitToClusterMap

private

Definition at line 100 of file DeltaRayMatchingAlgorithm.h.

typedef std::vector<Particle> lar_content::DeltaRayMatchingAlgorithm::ParticleList

private

Definition at line 93 of file DeltaRayMatchingAlgorithm.h.

typedef std::unordered_map<const pandora::ParticleFlowObject *, float> lar_content::DeltaRayMatchingAlgorithm::PfoLengthMap

private

Definition at line 146 of file DeltaRayMatchingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::DeltaRayMatchingAlgorithm::DeltaRayMatchingAlgorithm

(

)

Default constructor.

Definition at line 24 of file DeltaRayMatchingAlgorithm.cc.

                                                     :
    m_minCaloHitsPerCluster(3),
    m_xOverlapWindow(1.f),
    m_distanceForMatching(5.f),
    m_pseudoChi2Cut(3.f),
    m_searchRegion1D(5.f)
{
}

Member Function Documentation

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

private

Merge an input cluster list with an existing daughter Pfo.

Parameters

clusterList	the list of clusters
pParentPfo	address of the parent pfo

Definition at line 696 of file DeltaRayMatchingAlgorithm.cc.

{
    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));
    }
}

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

private

Look at consistency of a combination of clusters.

Parameters

pCluster1	pointer to first luster
pCluster2	pointer to second cluster
pCluster3	pointer to third cluster

Definition at line 436 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::ClearNearbyClusterMaps ( )

private

Clear nearby cluster maps.

Definition at line 125 of file DeltaRayMatchingAlgorithm.cc.

{
    m_nearbyClustersU.clear();
    m_nearbyClustersV.clear();
    m_nearbyClustersW.clear();
}

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

private

Create a new Pfo from an input cluster list and set up a parent/daughter relationship.

Parameters

clusterList	the list of clusters
pParentPfo	address of the parent pfo

Definition at line 669 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::CreateParticles ( const ParticleList &  particleList ) const

private

Build new particle flow objects.

Parameters

particleList

the list of candidate particles

Definition at line 385 of file DeltaRayMatchingAlgorithm.cc.

{
    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);
        }
    }
}

void lar_content::DeltaRayMatchingAlgorithm::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

private

Find best Pfo to associate a UVW triplet.

Parameters

pClusterU	pointer to U view cluster
pClusterV	pointer to V view cluster
pClusterW	pointer to W view cluster
clusterLengthMap	the cluster length map
pfoLengthMap	the pfo length map
pBestPfo	to receive the address of the best Pfo

Definition at line 521 of file DeltaRayMatchingAlgorithm.cc.

{
    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;
        }
    }
}

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

private

Get a vector of all Pfos in the provided input Pfo lists.

Parameters

inputPfoListName	the input Pfo list name
pfoVector	the output vector of Pfos

Definition at line 134 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::GetClusters ( const std::string &  clusterListName, pandora::ClusterVector &  clusterVector  ) const

private

Get a vector containing all available input clusters in the provided cluster list, storing sliding linear fits in the algorithm cache.

Parameters

clusterListName	the vector of cluster list names
clusterVector	to receive the populated cluster vector

Definition at line 170 of file DeltaRayMatchingAlgorithm.cc.

{
    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);
}

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

private

Get displacementr between cluster and particle flow object.

Parameters

pCluster	pointer to cluster
pPfo	pointer to particle flow object

Definition at line 634 of file DeltaRayMatchingAlgorithm.cc.

{
    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);
}

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

private

Get the length (squared) of a candidate particle.

Parameters

particle	the particle
clusterLengthMap	the cluster length map

Returns

the length (squared)

Definition at line 616 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::GetLengthFromCache ( const pandora::Cluster *const  pCluster, ClusterLengthMap &  clusterLengthMap  ) const

private

Reduce number of length (squared) calculations by caching results when they are first obtained.

Parameters

pCluster	the cluster
clusterLengthMap	the cluster length map

Returns

the length (squared)

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

private

Reduce number of length (squared) calculations by caching results when they are first obtained.

Parameters

pPfo	the pfo
pfoLengthMap	the pfo length map

Returns

the length (squared)

Definition at line 602 of file DeltaRayMatchingAlgorithm.cc.

{
    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;
}

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

private

Get a vector of track-like Pfos in the provided input Pfo lists.

Parameters

inputPfoListName	the input Pfo list name
pfoVector	the output vector of Pfos

Definition at line 150 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::InitializeNearbyClusterMap ( const std::string &  clusterListName, ClusterToClustersMap &  nearbyClusters  )

private

Initialize a nearby cluster map with details relating to a specific cluster list.

Parameters

clusterListName	the cluster list name
nearbyClustersMap	to receive the nearby clusters map

Definition at line 72 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::InitializeNearbyClusterMaps ( )

private

Initialize nearby cluster maps.

Definition at line 62 of file DeltaRayMatchingAlgorithm.cc.

{
    this->ClearNearbyClusterMaps();
    this->InitializeNearbyClusterMap(m_inputClusterListNameU, m_nearbyClustersU);
    this->InitializeNearbyClusterMap(m_inputClusterListNameV, m_nearbyClustersV);
    this->InitializeNearbyClusterMap(m_inputClusterListNameW, m_nearbyClustersW);
}

void lar_content::DeltaRayMatchingAlgorithm::OneViewMatching ( ClusterLengthMap &  clusterLengthMap ) const

private

Match clusters using single views.

Parameters

clusterLengthMap

the cluster length map

Definition at line 228 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::OneViewMatching ( const pandora::ClusterVector &  clusters, ClusterLengthMap &  clusterLengthMap, PfoLengthMap &  pfoLengthMap, ParticleList &  particleList  ) const

private

Match clusters using a single view.

Parameters

clusters	the list of clusters in the provided view
clusterLengthMap	the cluster length map
pfoLengthMap	the pfo length map
particleList	the output list of particles

StatusCode lar_content::DeltaRayMatchingAlgorithm::ReadSettings ( const pandora::TiXmlHandle  xmlHandle )

private

Definition at line 779 of file DeltaRayMatchingAlgorithm.cc.

{
    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;
}

StatusCode lar_content::DeltaRayMatchingAlgorithm::Run ( )

private

Definition at line 35 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::SelectParticles ( const ParticleList &  inputParticles, ClusterLengthMap &  clusterLengthMap, ParticleList &  outputParticles  ) const

private

Resolve any ambiguities between candidate particles.

Parameters

inputParticles	the input list of candidate particles
clusterLengthMap	the cluster length map
outputParticles	the output list of candidate particles

Definition at line 338 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::ThreeViewMatching ( ClusterLengthMap &  clusterLengthMap ) const

private

Match clusters using all three views.

Parameters

clusterLengthMap

the cluster length map

Definition at line 194 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::ThreeViewMatching ( const pandora::ClusterVector &  clusters1, const pandora::ClusterVector &  clusters2, const pandora::ClusterVector &  clusters3, ClusterLengthMap &  clusterLengthMap, PfoLengthMap &  pfoLengthMap, ParticleList &  particleList  ) const

private

Match clusters using all three views.

Parameters

clusters1	the list of clusters in the first view
clusters2	the list of clusters in the second view
clusters3	the list of clusters in the third view
clusterLengthMap	the cluster length map
pfoLengthMap	the pfo length map
particleList	the output list of particles

void lar_content::DeltaRayMatchingAlgorithm::TwoViewMatching ( ClusterLengthMap &  clusterLengthMap ) const

private

Match clusters using pairs of views.

Parameters

clusterLengthMap

the cluster length map

Definition at line 210 of file DeltaRayMatchingAlgorithm.cc.

{
    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 lar_content::DeltaRayMatchingAlgorithm::TwoViewMatching ( const pandora::ClusterVector &  clusters1, const pandora::ClusterVector &  clusters2, ClusterLengthMap &  clusterLengthMap, PfoLengthMap &  pfoLengthMap, ParticleList &  particleList  ) const

private

Match clusters using a pair of views.

Parameters

clusters1	the list of clusters in the first view
clusters2	the list of clusters in the second view
clusterLengthMap	the cluster length map
pfoLengthMap	the pfo length map
particleList	the output list of particles

Member Data Documentation

std::string lar_content::DeltaRayMatchingAlgorithm::m_daughterPfoListName

private

The daughter pfo list name for new daughter particles.

Definition at line 300 of file DeltaRayMatchingAlgorithm.h.

float lar_content::DeltaRayMatchingAlgorithm::m_distanceForMatching

private

The maximum allowed distance between tracks and delta rays.

Definition at line 308 of file DeltaRayMatchingAlgorithm.h.

std::string lar_content::DeltaRayMatchingAlgorithm::m_inputClusterListNameU

private

The input cluster list name for the u view.

Definition at line 302 of file DeltaRayMatchingAlgorithm.h.

std::string lar_content::DeltaRayMatchingAlgorithm::m_inputClusterListNameV

private

The input cluster list name for the v view.

Definition at line 303 of file DeltaRayMatchingAlgorithm.h.

std::string lar_content::DeltaRayMatchingAlgorithm::m_inputClusterListNameW

private

The input cluster list name for the w view.

Definition at line 304 of file DeltaRayMatchingAlgorithm.h.

unsigned int lar_content::DeltaRayMatchingAlgorithm::m_minCaloHitsPerCluster

private

The min number of calo hits per candidate cluster.

Definition at line 306 of file DeltaRayMatchingAlgorithm.h.

ClusterToClustersMap lar_content::DeltaRayMatchingAlgorithm::m_nearbyClustersU

private

The nearby clusters map for the u view.

Definition at line 312 of file DeltaRayMatchingAlgorithm.h.

ClusterToClustersMap lar_content::DeltaRayMatchingAlgorithm::m_nearbyClustersV

private

The nearby clusters map for the v view.

Definition at line 313 of file DeltaRayMatchingAlgorithm.h.

ClusterToClustersMap lar_content::DeltaRayMatchingAlgorithm::m_nearbyClustersW

private

The nearby clusters map for the w view.

Definition at line 314 of file DeltaRayMatchingAlgorithm.h.

std::string lar_content::DeltaRayMatchingAlgorithm::m_parentPfoListName

private

The parent pfo list name.

Definition at line 299 of file DeltaRayMatchingAlgorithm.h.

float lar_content::DeltaRayMatchingAlgorithm::m_pseudoChi2Cut

private

Pseudo chi2 cut for three view matching.

Definition at line 309 of file DeltaRayMatchingAlgorithm.h.

float lar_content::DeltaRayMatchingAlgorithm::m_searchRegion1D

private

Search region, applied to each dimension, for look-up from kd-trees.

Definition at line 311 of file DeltaRayMatchingAlgorithm.h.

float lar_content::DeltaRayMatchingAlgorithm::m_xOverlapWindow

private

The maximum allowed displacement in x position.

Definition at line 307 of file DeltaRayMatchingAlgorithm.h.

---

The documentation for this class was generated from the following files:

• larpandoracontent/larpandoracontent/LArThreeDReco/LArCosmicRay/DeltaRayMatchingAlgorithm.h
• larpandoracontent/larpandoracontent/LArThreeDReco/LArCosmicRay/DeltaRayMatchingAlgorithm.cc