DeltaRayIdentificationAlgorithm class. More...

#include <DeltaRayIdentificationAlgorithm.h>

Inheritance diagram for lar_content::DeltaRayIdentificationAlgorithm:

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

Private Types
typedef std::unordered_map < const pandora::ParticleFlowObject , const pandora::ParticleFlowObject >	PfoAssociationMap

Private Member Functions
pandora::StatusCode	Run ()

void	GetPfos (const std::string &inputPfoListName, pandora::PfoVector &outputPfoVector) const
	Get the vector of Pfos, given the input list name. More...

void	BuildAssociationMap (const pandora::PfoVector &inputPfos, const pandora::PfoVector &outputPfos, PfoAssociationMap &pfoAssociationMap) const
	Build parent/daughter associations between PFOs. More...

bool	IsAssociated (const pandora::ParticleFlowObject const pDaughterPfo, const pandora::ParticleFlowObject const pParentPfo, float &displacement) const
	Determine if a given pair of Pfos have a parent/daughter association. More...

float	GetTwoDSeparation (const pandora::ParticleFlowObject const pDaughterPfo, const pandora::ParticleFlowObject const pParentPfo) const
	Calculate 2D separation between two Pfos. More...

void	GetTwoDVertices (const pandora::ParticleFlowObject *const pPfo, const pandora::HitType &hitType, pandora::CartesianPointVector &vertexVector) const
	Calculate 2D separation between two Pfos. More...

float	GetClosestDistance (const pandora::CartesianPointVector &vertexVector, const pandora::ClusterList &clusterList) const
	Calculate closest 2D separation between a set of vertices and a set of clusters. More...

void	BuildParentDaughterLinks (const PfoAssociationMap &pfoAssociationMap, pandora::PfoList &outputPfoList) const
	Build the parent/daughter links from the map of parent/daughter associations. More...

const pandora::ParticleFlowObject *	GetParent (const PfoAssociationMap &pfoAssociationMap, const pandora::ParticleFlowObject *const pPfo) const
	For a given daughter, follow the parent/daughter links to find the overall parent. 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. More...

float	m_distanceForMatching
	Maximum allowed distance of delta ray from parent cosmic ray. More...

float	m_minParentLengthSquared
	Minimum allowed length of parent cosmic ray. More...

float	m_maxDaughterLengthSquared
	Maximum allowed length of daughter delta ray. More...

Detailed Description

DeltaRayIdentificationAlgorithm class.

Definition at line 21 of file DeltaRayIdentificationAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::ParticleFlowObject *, const pandora::ParticleFlowObject *> lar_content::DeltaRayIdentificationAlgorithm::PfoAssociationMap

private

Definition at line 32 of file DeltaRayIdentificationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::DeltaRayIdentificationAlgorithm::DeltaRayIdentificationAlgorithm ( )

Default constructor.

Definition at line 21 of file DeltaRayIdentificationAlgorithm.cc.

                                                                  :
     m_distanceForMatching(3.f),
     m_minParentLengthSquared(10.f * 10.f),
     m_maxDaughterLengthSquared(175.f * 175.f)
 {
 }

Member Function Documentation

void lar_content::DeltaRayIdentificationAlgorithm::BuildAssociationMap	(	const pandora::PfoVector &	inputPfos,
		const pandora::PfoVector &	outputPfos,
		PfoAssociationMap &	pfoAssociationMap
	)		const

private

Build parent/daughter associations between PFOs.

Parameters

inputPfos	the input vector of current parent Pfos
outputPfos	the input vector of current daughter Pfos
pfoAssociationMap	the output map of parent/daughter associations

Definition at line 76 of file DeltaRayIdentificationAlgorithm.cc.

 {
     PfoSet parentPfoList, daughterPfoList;
     parentPfoList.insert(parentPfos.begin(), parentPfos.end());
     daughterPfoList.insert(daughterPfos.begin(), daughterPfos.end());
 
     PfoVector allPfos(parentPfos.begin(), parentPfos.end());
     allPfos.insert(allPfos.end(), daughterPfos.begin(), daughterPfos.end());
 
     // Loop over possible daughter Pfos in primary list
     for (PfoVector::const_iterator iter1 = parentPfos.begin(), iterEnd1 = parentPfos.end(); iter1 != iterEnd1; ++iter1)
     {
         const ParticleFlowObject *const pDaughterPfo = *iter1;
 
         // Find the best parent Pfo using combined list
         const ParticleFlowObject *pBestParentPfo = NULL;
         float bestDisplacement(std::numeric_limits<float>::max());
 
         for (PfoVector::const_iterator iter2 = allPfos.begin(), iterEnd2 = allPfos.end(); iter2 != iterEnd2; ++iter2)
         {
             const ParticleFlowObject *const pThisParentPfo = *iter2;
             float thisDisplacement(std::numeric_limits<float>::max());
 
             if (pDaughterPfo == pThisParentPfo)
                 continue;
 
             if (!this->IsAssociated(pDaughterPfo, pThisParentPfo, thisDisplacement))
                 continue;
 
             if (thisDisplacement < bestDisplacement)
             {
                 bestDisplacement = thisDisplacement;
                 pBestParentPfo = pThisParentPfo;
             }
         }
 
         if (!pBestParentPfo)
             continue;
 
         // Case 1: candidate parent comes from primary list
         if (pBestParentPfo->GetParentPfoList().empty())
         {
             // Check: parent shouldn't live in the secondary list
             if (daughterPfoList.count(pBestParentPfo))
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             pfoAssociationMap.insert(PfoAssociationMap::value_type(pDaughterPfo, pBestParentPfo));
         }
 
         // Case 2: candidate parent comes from secondary list
         else
         {
             // Check: parent shouldn't live in the primary list
             if (parentPfoList.count(pBestParentPfo))
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             // Check: there should only be one parent
             if (pBestParentPfo->GetParentPfoList().size() != 1)
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             // Check: get the new parent (and check there is no grand-parent)
             PfoList::const_iterator pIter = pBestParentPfo->GetParentPfoList().begin();
             const ParticleFlowObject *const pReplacementParentPfo = *pIter;
             if (pReplacementParentPfo->GetParentPfoList().size() != 0)
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             pfoAssociationMap.insert(PfoAssociationMap::value_type(pDaughterPfo, pReplacementParentPfo));
         }
     }
 }

void lar_content::DeltaRayIdentificationAlgorithm::BuildParentDaughterLinks	(	const PfoAssociationMap &	pfoAssociationMap,
		pandora::PfoList &	outputPfoList
	)		const

private

Build the parent/daughter links from the map of parent/daughter associations.

Parameters

pfoAssociationMap	the map of parent/daughter associations
outputPfoList	the output list of daughter Pfos

Definition at line 275 of file DeltaRayIdentificationAlgorithm.cc.

 {
     PfoList pfoList;
     for (const auto &mapEntry : pfoAssociationMap)
         pfoList.push_back(mapEntry.first);
     pfoList.sort(LArPfoHelper::SortByNHits);
 
     for (const ParticleFlowObject *const pDaughterPfo : pfoList)
     {
         const ParticleFlowObject *const pParentPfo(this->GetParent(pfoAssociationMap, pDaughterPfo));
 
         if (!pParentPfo)
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         if (!LArPfoHelper::IsTrack(pParentPfo))
             continue;
 
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*this, pParentPfo, pDaughterPfo));
 
         PandoraContentApi::ParticleFlowObject::Metadata metadata;
         metadata.m_particleId = E_MINUS;
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pDaughterPfo, metadata));
 
         daughterPfoList.push_back(pDaughterPfo);
     }
 }

float lar_content::DeltaRayIdentificationAlgorithm::GetClosestDistance	(	const pandora::CartesianPointVector &	vertexVector,
		const pandora::ClusterList &	clusterList
	)		const

private

Calculate closest 2D separation between a set of vertices and a set of clusters.

Parameters

vertexVector	the vector of possible vertex positions
clusterList	the list of clusters

Definition at line 249 of file DeltaRayIdentificationAlgorithm.cc.

 {
     if (vertexVector.empty() || clusterList.empty())
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     float bestDisplacement(std::numeric_limits<float>::max());
 
     for (CartesianPointVector::const_iterator iter1 = vertexVector.begin(), iterEnd1 = vertexVector.end(); iter1 != iterEnd1; ++iter1)
     {
         const CartesianVector &thisVertex = *iter1;
 
         for (ClusterList::const_iterator iter2 = clusterList.begin(), iterEnd2 = clusterList.end(); iter2 != iterEnd2; ++iter2)
         {
             const Cluster *const pCluster = *iter2;
             const float thisDisplacement(LArClusterHelper::GetClosestDistance(thisVertex, pCluster));
 
             if (thisDisplacement < bestDisplacement)
                 bestDisplacement = thisDisplacement;
         }
     }
 
     return bestDisplacement;
 }

const ParticleFlowObject * lar_content::DeltaRayIdentificationAlgorithm::GetParent	(	const PfoAssociationMap &	pfoAssociationMap,
		const pandora::ParticleFlowObject *const	pPfo
	)		const

private

For a given daughter, follow the parent/daughter links to find the overall parent.

Parameters

pfoAssociationMap	the map of parent/daughter associations
pPfo	the daughter Pfo

Returns: the parent Pfo

Definition at line 304 of file DeltaRayIdentificationAlgorithm.cc.

 {
     const ParticleFlowObject *pParentPfo = nullptr;
     const ParticleFlowObject *pDaughterPfo = pPfo;
 
     while (1)
     {
         PfoAssociationMap::const_iterator iter = pfoAssociationMap.find(pDaughterPfo);
         if (pfoAssociationMap.end() == iter)
             break;
 
         pParentPfo = iter->second;
         pDaughterPfo = pParentPfo;
     }
 
     return pParentPfo;
 }

void lar_content::DeltaRayIdentificationAlgorithm::GetPfos	(	const std::string &	inputPfoListName,
		pandora::PfoVector &	outputPfoVector
	)		const

private

Get the vector of Pfos, given the input list name.

Parameters

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

Definition at line 62 of file DeltaRayIdentificationAlgorithm.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;
 
     outputPfoVector.insert(outputPfoVector.end(), pPfoList->begin(), pPfoList->end());
     std::sort(outputPfoVector.begin(), outputPfoVector.end(), LArPfoHelper::SortByNHits);
 }

float lar_content::DeltaRayIdentificationAlgorithm::GetTwoDSeparation	(	const pandora::ParticleFlowObject *const	pDaughterPfo,
		const pandora::ParticleFlowObject *const	pParentPfo
	)		const

private

Calculate 2D separation between two Pfos.

Parameters

pDaughterPfo	the input daughter Pfo
pParentPfo	the input parent Pfo

Returns: average displacement between parent and daughter

Definition at line 186 of file DeltaRayIdentificationAlgorithm.cc.

 {
     CartesianPointVector vertexVectorU, vertexVectorV, vertexVectorW;
     this->GetTwoDVertices(pDaughterPfo, TPC_VIEW_U, vertexVectorU);
     this->GetTwoDVertices(pDaughterPfo, TPC_VIEW_V, vertexVectorV);
     this->GetTwoDVertices(pDaughterPfo, TPC_VIEW_W, vertexVectorW);
 
     ClusterList clusterListU, clusterListV, clusterListW;
     LArPfoHelper::GetClusters(pParentPfo, TPC_VIEW_U, clusterListU);
     LArPfoHelper::GetClusters(pParentPfo, TPC_VIEW_V, clusterListV);
     LArPfoHelper::GetClusters(pParentPfo, TPC_VIEW_W, clusterListW);
 
     float sumViews(0.f);
     float sumDisplacementSquared(0.f);
 
     if (!vertexVectorU.empty())
     {
         const float thisDisplacement(this->GetClosestDistance(vertexVectorU, clusterListU));
         sumDisplacementSquared += thisDisplacement * thisDisplacement;
         sumViews += 1.f;
     }
 
     if (!vertexVectorV.empty())
     {
         const float thisDisplacement(this->GetClosestDistance(vertexVectorV, clusterListV));
         sumDisplacementSquared += thisDisplacement * thisDisplacement;
         sumViews += 1.f;
     }
 
     if (!vertexVectorW.empty())
     {
         const float thisDisplacement(this->GetClosestDistance(vertexVectorW, clusterListW));
         sumDisplacementSquared += thisDisplacement * thisDisplacement;
         sumViews += 1.f;
     }
 
     if (sumViews < std::numeric_limits<float>::epsilon())
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     return std::sqrt(sumDisplacementSquared / sumViews);
 }

void lar_content::DeltaRayIdentificationAlgorithm::GetTwoDVertices	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::HitType &	hitType,
		pandora::CartesianPointVector &	vertexVector
	)		const

private

Calculate 2D separation between two Pfos.

Parameters

pPfo	the input daughter Pfo
hitType	the hit type
vertexVector	the vector of possible vertex positions

Definition at line 230 of file DeltaRayIdentificationAlgorithm.cc.

 {
     ClusterList clusterList;
     LArPfoHelper::GetClusters(pPfo, hitType, clusterList);
 
     for (ClusterList::const_iterator iter = clusterList.begin(), iterEnd = clusterList.end(); iter != iterEnd; ++iter)
     {
         const Cluster *const pCluster = *iter;
 
         CartesianVector firstCoordinate(0.f, 0.f, 0.f), secondCoordinate(0.f, 0.f, 0.f);
         LArClusterHelper::GetExtremalCoordinates(pCluster, firstCoordinate, secondCoordinate);
 
         vertexVector.push_back(firstCoordinate);
         vertexVector.push_back(secondCoordinate);
     }
 }

bool lar_content::DeltaRayIdentificationAlgorithm::IsAssociated	(	const pandora::ParticleFlowObject *const	pDaughterPfo,
		const pandora::ParticleFlowObject *const	pParentPfo,
		float &	displacement
	)		const

private

Determine if a given pair of Pfos have a parent/daughter association.

Parameters

pDaughterPfo	the input daughter Pfo
pParentPfo	the input parent Pfo
displacement	the average displacement between parent and daughter

Returns: boolean

Definition at line 149 of file DeltaRayIdentificationAlgorithm.cc.

 {
     displacement = std::numeric_limits<float>::max();
 
     if (pDaughterPfo == pParentPfo)
         return false;
 
     const float daughterLengthSquared(LArPfoHelper::GetTwoDLengthSquared(pDaughterPfo));
     const float parentLengthSquared(LArPfoHelper::GetTwoDLengthSquared(pParentPfo));
 
     if (daughterLengthSquared > m_maxDaughterLengthSquared || parentLengthSquared < m_minParentLengthSquared || daughterLengthSquared > 0.5 * parentLengthSquared)
         return false;
 
     const float transitionLengthSquared(125.f);
     const float displacementCut((daughterLengthSquared > transitionLengthSquared)
                                     ? m_distanceForMatching
                                     : m_distanceForMatching * (2.f - daughterLengthSquared / transitionLengthSquared));
 
     try
     {
         displacement = this->GetTwoDSeparation(pDaughterPfo, pParentPfo);
     }
     catch (StatusCodeException &statusCodeException)
     {
         if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
             throw statusCodeException;
     }
 
     if (displacement > displacementCut)
         return false;
 
     return true;
 }

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

private

Definition at line 324 of file DeltaRayIdentificationAlgorithm.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_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DistanceForMatching", m_distanceForMatching));
 
     float minParentLength = std::sqrt(m_minParentLengthSquared);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinParentLength", minParentLength));
     m_minParentLengthSquared = minParentLength * minParentLength;
 
     float maxDaughterLength = std::sqrt(m_maxDaughterLengthSquared);
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxDaughterLength", maxDaughterLength));
     m_maxDaughterLengthSquared = maxDaughterLength * maxDaughterLength;
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::DeltaRayIdentificationAlgorithm::Run ( )

private

Definition at line 30 of file DeltaRayIdentificationAlgorithm.cc.

 {
     PfoVector parentPfos, daughterPfos;
     this->GetPfos(m_parentPfoListName, parentPfos);
     this->GetPfos(m_daughterPfoListName, daughterPfos);
 
     if (parentPfos.empty())
     {
         if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
             std::cout << "DeltaRayIdentificationAlgorithm: pfo list " << m_parentPfoListName << " unavailable." << std::endl;
         return STATUS_CODE_SUCCESS;
     }
 
     // Build parent/daughter associations (currently using length and proximity)
     PfoAssociationMap pfoAssociationMap;
     this->BuildAssociationMap(parentPfos, daughterPfos, pfoAssociationMap);
 
     // Create the parent/daughter links
     PfoList newDaughterPfoList;
     this->BuildParentDaughterLinks(pfoAssociationMap, newDaughterPfoList);
 
     if (!newDaughterPfoList.empty())
     {
         PANDORA_THROW_RESULT_IF(
             STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList(*this, m_parentPfoListName, m_daughterPfoListName, newDaughterPfoList));
     }
 
     return STATUS_CODE_SUCCESS;
 }