lar_content::DeltaRayParentAlgorithm Class Reference

DeltaRayParentAlgorithm class. More...

#include <DeltaRayParentAlgorithm.h>

Inheritance diagram for lar_content::DeltaRayParentAlgorithm:

Public Types
typedef std::map< const pandora::ParticleFlowObject *, float >	PfoLengthMap

Public Member Functions
	DeltaRayParentAlgorithm ()
	Default constructor. More...
pandora::StatusCode	Run ()

Private Member Functions
void	InitialisePfoLengthMap (const pandora::PfoList *const muonPfoList, const pandora::PfoList *const deltaRayPfoList, PfoLengthMap &pfoLengthMap) const
	Initialise the delta ray pfo length map. More...
void	FindParentPfo (const PfoLengthMap &pfoLengthMap, const pandora::ParticleFlowObject *const pPfo, const pandora::ParticleFlowObject *&pParentPfo) const
	Identify the parent pfo of a given delta ray pfo (can be either a cosmic ray or delta ray pfo) More...
pandora::StatusCode	GetTwoDSeparation (const pandora::ParticleFlowObject *const pPfo1, const pandora::ParticleFlowObject *const pPfo2, float &separation) const
	Get distance between two Pfos using 2D clusters. More...
void	AssignToParentPfo (const pandora::PfoList *const muonPfoList, const pandora::PfoList *const deltaRayPfoList, const pandora::ParticleFlowObject *const pPfo, const pandora::ParticleFlowObject *const pParentPfo, PfoLengthMap &pfoLengthMap) const
	Apply parent-child link (if parent is a cosmic ray create parent-child link else merge the delta ray cluster into parent delta ray pfo) More...
void	UpdatePfoLengthMap (const pandora::PfoList &pfosToRemove, const pandora::ParticleFlowObject *const pPfoToAdd, PfoLengthMap &pfoLengthMap) const
	Update the pfo length map after a parent-child delta ray merge. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Private Attributes
std::string	m_muonPfoListName
	The list of reconstructed muon pfos. More...
std::string	m_deltaRayPfoListName
	The list of reconstructed delta ray pfos. More...
float	m_distanceForMatching
	The maximum separation of a delta ray pfo from its parent. More...

Detailed Description

DeltaRayParentAlgorithm class.

Definition at line 19 of file DeltaRayParentAlgorithm.h.

Member Typedef Documentation

typedef std::map<const pandora::ParticleFlowObject *, float> lar_content::DeltaRayParentAlgorithm::PfoLengthMap

Definition at line 22 of file DeltaRayParentAlgorithm.h.

Constructor & Destructor Documentation

lar_content::DeltaRayParentAlgorithm::DeltaRayParentAlgorithm

(

)

Default constructor.

Definition at line 21 of file DeltaRayParentAlgorithm.cc.

                                                 : m_distanceForMatching(5.f)
{
}

Member Function Documentation

void lar_content::DeltaRayParentAlgorithm::AssignToParentPfo ( const pandora::PfoList *const  muonPfoList, const pandora::PfoList *const  deltaRayPfoList, const pandora::ParticleFlowObject *const  pPfo, const pandora::ParticleFlowObject *const  pParentPfo, PfoLengthMap &  pfoLengthMap  ) const

private

Apply parent-child link (if parent is a cosmic ray create parent-child link else merge the delta ray cluster into parent delta ray pfo)

Parameters

muonPfoList	the list of all cosmic ray pfos
deltaRayPfoList	the list of all delta ray pfos
pPfo	the address of the input delta ray pfo
pParentPfo	the address of the parent pfo
pfoLengthMap	the mapping of pfos to their 2D length

Definition at line 165 of file DeltaRayParentAlgorithm.cc.

{
    if (std::find(pMuonPfoList->begin(), pMuonPfoList->end(), pParentPfo) != pMuonPfoList->end())
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*this, pParentPfo, pPfo));

    if (std::find(pDeltaRayPfoList->begin(), pDeltaRayPfoList->end(), pParentPfo) != pDeltaRayPfoList->end())
    {
        ClusterList pfoClusters;
        LArPfoHelper::GetTwoDClusterList(pPfo, pfoClusters);

        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*this, pPfo, m_deltaRayPfoListName));

        for (const Cluster *const pCluster : pfoClusters)
            PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToPfo(*this, pParentPfo, pCluster));

        this->UpdatePfoLengthMap({pPfo, pParentPfo}, pParentPfo, pfoLengthMap);
    }
}

void lar_content::DeltaRayParentAlgorithm::FindParentPfo ( const PfoLengthMap &  pfoLengthMap, const pandora::ParticleFlowObject *const  pPfo, const pandora::ParticleFlowObject *&  pParentPfo  ) const

private

Identify the parent pfo of a given delta ray pfo (can be either a cosmic ray or delta ray pfo)

Parameters

pfoLengthMap	the mapping of pfos to their 2D length
pPfo	the address of the input delta ray pfo
pParentPfo	the output address of the parent pfo

Definition at line 79 of file DeltaRayParentAlgorithm.cc.

{
    const PfoLengthMap::const_iterator currentIter(pfoLengthMap.find(pPfo));

    if (currentIter == pfoLengthMap.end())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    PfoVector allPfoVector;

    for (auto &entry : pfoLengthMap)
        allPfoVector.push_back(entry.first);

    const float lengthSquared(currentIter->second);
    float bestDistance(m_distanceForMatching);

    for (const ParticleFlowObject *const pTestParent : allPfoVector)
    {
        if (pTestParent == pPfo)
            continue;

        const PfoLengthMap::const_iterator testIter(pfoLengthMap.find(pTestParent));

        if (testIter == pfoLengthMap.end())
            throw StatusCodeException(STATUS_CODE_FAILURE);

        if (testIter->second < lengthSquared)
            continue;

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

        if (this->GetTwoDSeparation(pPfo, pTestParent, distance) == STATUS_CODE_NOT_FOUND)
            continue;

        if (distance < bestDistance)
        {
            pParentPfo = pTestParent;
            bestDistance = distance;
        }
    }
}

StatusCode lar_content::DeltaRayParentAlgorithm::GetTwoDSeparation ( const pandora::ParticleFlowObject *const  pPfo1, const pandora::ParticleFlowObject *const  pPfo2, float &  separation  ) const

private

Get distance between two Pfos using 2D clusters.

Parameters

pPfo	the address of the first Pfo
pPfo	the address of the second Pfo
to	recieve the output pfo separation

Returns

whether the pfo separation could be calculated

Definition at line 122 of file DeltaRayParentAlgorithm.cc.

{
    ClusterList clusterListU1, clusterListV1, clusterListW1;
    ClusterList clusterListU2, clusterListV2, clusterListW2;

    LArPfoHelper::GetClusters(pPfo1, TPC_VIEW_U, clusterListU1);
    LArPfoHelper::GetClusters(pPfo1, TPC_VIEW_V, clusterListV1);
    LArPfoHelper::GetClusters(pPfo1, TPC_VIEW_W, clusterListW1);

    LArPfoHelper::GetClusters(pPfo2, TPC_VIEW_U, clusterListU2);
    LArPfoHelper::GetClusters(pPfo2, TPC_VIEW_V, clusterListV2);
    LArPfoHelper::GetClusters(pPfo2, TPC_VIEW_W, clusterListW2);

    float numViews(0.f), distance(0.f);

    if (!clusterListU1.empty() && !clusterListU2.empty())
    {
        distance += LArClusterHelper::GetClosestDistance(clusterListU1, clusterListU2);
        numViews += 1.f;
    }

    if (!clusterListV1.empty() && !clusterListV2.empty())
    {
        distance += LArClusterHelper::GetClosestDistance(clusterListV1, clusterListV2);
        numViews += 1.f;
    }

    if (!clusterListW1.empty() && !clusterListW2.empty())
    {
        distance += LArClusterHelper::GetClosestDistance(clusterListW1, clusterListW2);
        numViews += 1.f;
    }

    if (numViews < std::numeric_limits<float>::epsilon())
        return STATUS_CODE_NOT_FOUND;

    separation = distance / numViews;

    return STATUS_CODE_SUCCESS;
}

void lar_content::DeltaRayParentAlgorithm::InitialisePfoLengthMap ( const pandora::PfoList *const  muonPfoList, const pandora::PfoList *const  deltaRayPfoList, PfoLengthMap &  pfoLengthMap  ) const

private

Initialise the delta ray pfo length map.

Parameters

muonPfoList	the list of all cosmic ray pfos
deltaRayPfoList	the list of all delta ray pfos
pfoLengthMap	the output mapping of pfos to their 2D length

Definition at line 68 of file DeltaRayParentAlgorithm.cc.

{
    for (const ParticleFlowObject *const pPfo : *muonPfoList)
        pfoLengthMap[pPfo] = LArPfoHelper::GetTwoDLengthSquared(pPfo);

    for (const ParticleFlowObject *const pPfo : *deltaRayPfoList)
        pfoLengthMap[pPfo] = LArPfoHelper::GetTwoDLengthSquared(pPfo);
}

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

private

Definition at line 204 of file DeltaRayParentAlgorithm.cc.

{
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "MuonPfoListName", m_muonPfoListName));

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "DeltaRayPfoListName", m_deltaRayPfoListName));

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

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::DeltaRayParentAlgorithm::Run

(

)

Definition at line 27 of file DeltaRayParentAlgorithm.cc.

{
    const PfoList *pMuonPfoList(nullptr);
    PANDORA_THROW_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, m_muonPfoListName, pMuonPfoList));

    if (!pMuonPfoList || pMuonPfoList->empty())
        return STATUS_CODE_SUCCESS;

    const PfoList *pDeltaRayPfoList(nullptr);
    PANDORA_THROW_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, m_deltaRayPfoListName, pDeltaRayPfoList));

    if (!pDeltaRayPfoList || pDeltaRayPfoList->empty())
        return STATUS_CODE_SUCCESS;

    PfoLengthMap pfoLengthMap;
    this->InitialisePfoLengthMap(pMuonPfoList, pDeltaRayPfoList, pfoLengthMap);

    PfoVector deltaRayPfoVector(pDeltaRayPfoList->begin(), pDeltaRayPfoList->end());
    std::sort(deltaRayPfoVector.begin(), deltaRayPfoVector.end(), LArPfoHelper::SortByNHits);

    for (const ParticleFlowObject *const pPfo : deltaRayPfoVector)
    {
        if (!pPfo->GetParentPfoList().empty())
            continue;

        const ParticleFlowObject *pParentPfo(nullptr);
        this->FindParentPfo(pfoLengthMap, pPfo, pParentPfo);

        if (!pParentPfo)
            continue;

        this->AssignToParentPfo(pMuonPfoList, pDeltaRayPfoList, pPfo, pParentPfo, pfoLengthMap);
    }

    return STATUS_CODE_SUCCESS;
}

void lar_content::DeltaRayParentAlgorithm::UpdatePfoLengthMap ( const pandora::PfoList &  pfosToRemove, const pandora::ParticleFlowObject *const  pPfoToAdd, PfoLengthMap &  pfoLengthMap  ) const

private

Update the pfo length map after a parent-child delta ray merge.

Parameters

pfosToRemove	the list of pfos to remove from the map
pPfoToAdd	the address of the pfo to add to the map
pfoLengthMap	the mapping of pfos to their 2D length

Definition at line 187 of file DeltaRayParentAlgorithm.cc.

{
    for (const ParticleFlowObject *const pPfoToRemove : pfosToRemove)
    {
        const PfoLengthMap::const_iterator iter(pfoLengthMap.find(pPfoToRemove));

        if (iter == pfoLengthMap.end())
            throw StatusCodeException(STATUS_CODE_FAILURE);

        pfoLengthMap.erase(iter);
    }

    pfoLengthMap[pPfoToAdd] = LArPfoHelper::GetTwoDLengthSquared(pPfoToAdd);
}

Member Data Documentation

std::string lar_content::DeltaRayParentAlgorithm::m_deltaRayPfoListName

private

The list of reconstructed delta ray pfos.

Definition at line 86 of file DeltaRayParentAlgorithm.h.

float lar_content::DeltaRayParentAlgorithm::m_distanceForMatching

private

The maximum separation of a delta ray pfo from its parent.

Definition at line 87 of file DeltaRayParentAlgorithm.h.

std::string lar_content::DeltaRayParentAlgorithm::m_muonPfoListName

private

The list of reconstructed muon pfos.

Definition at line 85 of file DeltaRayParentAlgorithm.h.

---

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

• DeltaRayParentAlgorithm.h
• DeltaRayParentAlgorithm.cc