#include <ShowerGrowingAlgorithm.h>

Inheritance diagram for lar_content::ShowerGrowingAlgorithm:

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

Protected Types
typedef std::unordered_map < const pandora::Cluster *, LArVertexHelper::ClusterDirection >	ClusterDirectionMap

Protected Types inherited from lar_content::BranchGrowingAlgorithm
enum	AssociationType { NONE = 0, SINGLE_ORDER = 1, STANDARD = 2, STRONG = 3 }
	AssociationType enum. More...

typedef std::unordered_map < const pandora::Cluster *, Association >	ClusterAssociationMap

typedef std::unordered_map < const pandora::Cluster *, ClusterAssociationMap >	ClusterUsageMap

typedef std::unordered_map < const pandora::Cluster *, pandora::ClusterVector >	SeedAssociationList

Protected Member Functions
bool	IsVertexAssociated (const LArPointingCluster &pointingCluster, const pandora::CartesianVector &vertexPosition2D) const
	Whether a pointing cluster is assciated with a provided 2D vertex projection. More...

Protected Member Functions inherited from lar_content::BranchGrowingAlgorithm
void	FindAssociatedClusters (const pandora::Cluster *const pParticleSeed, pandora::ClusterVector &candidateClusters, ClusterUsageMap &forwardUsageMap, ClusterUsageMap &backwardUsageMap) const
	Find clusters associated with a particle seed. More...

void	IdentifyClusterMerges (const pandora::ClusterVector &particleSeedVector, const ClusterUsageMap &backwardUsageMap, SeedAssociationList &seedAssociationList) const
	Identify cluster merges. More...

Static Protected Member Functions
static bool	SortClusters (const pandora::Cluster const pLhs, const pandora::Cluster const pRhs)
	Sorting for clusters to determine order in which seeds are considered. More...

Protected Attributes
ClusterDirectionMap	m_clusterDirectionMap
	The cluster direction map. More...

Private Member Functions
pandora::StatusCode	Run ()

void	SimpleModeShowerGrowing (const pandora::ClusterList *const pClusterList, const std::string &clusterListName) const
	Simple single-pass shower growing mode. More...

bool	GetNextSeedCandidate (const pandora::ClusterList const pClusterList, const pandora::ClusterSet &usedClusters, const pandora::Cluster &pSeedCluster) const
	Get the next seed candidate, using a list of available candidates and a list of those already used. More...

void	GetAllVertexSeedCandidates (const pandora::ClusterList const pClusterList, const pandora::Vertex const pVertex, pandora::ClusterVector &seedClusters) const
	Get all seed candidates associated with a provided vertex. More...

void	GetSeedAssociationList (const pandora::ClusterVector &particleSeedVector, const pandora::ClusterList *const pClusterList, SeedAssociationList &seedAssociationList) const
	Get the seed association list for a given vector of particle seed candidates. More...

void	ProcessSeedAssociationDetails (const SeedAssociationList &seedAssociationList, const std::string &clusterListName, pandora::ClusterSet &usedClusters) const
	Process the details stored in a specified seed association list. More...

void	ProcessBranchClusters (const pandora::Cluster *const pParentCluster, const pandora::ClusterVector &branchClusters, const std::string &listName) const
	Process the list of branch clusters, merging with specified parent cluster, dealing with any existing pfos as required. More...

AssociationType	AreClustersAssociated (const pandora::Cluster const pClusterSeed, const pandora::Cluster const pCluster) const
	Determine whether two clusters are associated. More...

float	GetFigureOfMerit (const SeedAssociationList &seedAssociationList) const
	Get a figure of merit representing the consistency of the provided seed associated list. More...

unsigned int	GetNVertexConnections (const pandora::CartesianVector &vertexPosition2D, const LArPointingClusterList &pointingClusterList) const
	Get the number of clusters associated with the vertex. More...

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

Private Attributes
pandora::StringVector	m_inputClusterListNames
	The names of the input cluster lists. More...

unsigned int	m_minCaloHitsPerCluster
	The minimum number of calo hits per (seed or branch) cluster. More...

float	m_nearbyClusterDistance
	The nearby cluster distance, used for determining cluster associations. More...

float	m_remoteClusterDistance
	The remote cluster distance, used for determining cluster associations. More...

float	m_directionTanAngle
	Direction determination, look for vertex inside triangle with apex shifted along the cluster length. More...

float	m_directionApexShift
	Direction determination, look for vertex inside triangle with apex shifted along the cluster length. More...

float	m_minVertexLongitudinalDistance
	Vertex association check: min longitudinal distance cut. More...

float	m_maxVertexLongitudinalDistance
	Vertex association check: max longitudinal distance cut. More...

float	m_maxVertexTransverseDistance
	Vertex association check: max transverse distance cut. More...

float	m_vertexAngularAllowance
	Vertex association check: pointing angular allowance in degrees. More...

Detailed Description

ShowerGrowingAlgorithm class.

Definition at line 27 of file ShowerGrowingAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, LArVertexHelper::ClusterDirection> lar_content::ShowerGrowingAlgorithm::ClusterDirectionMap

protected

Definition at line 54 of file ShowerGrowingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::ShowerGrowingAlgorithm::ShowerGrowingAlgorithm ( )

Default constructor.

Definition at line 25 of file ShowerGrowingAlgorithm.cc.

                                                :
     m_minCaloHitsPerCluster(5),
     m_nearbyClusterDistance(2.5f),
     m_remoteClusterDistance(10.f),
     m_directionTanAngle(1.732f),
     m_directionApexShift(0.333f),
     m_minVertexLongitudinalDistance(-2.5f),
     m_maxVertexLongitudinalDistance(20.f),
     m_maxVertexTransverseDistance(1.5f),
     m_vertexAngularAllowance(3.f)
 {
 }

Member Function Documentation

ShowerGrowingAlgorithm::AssociationType lar_content::ShowerGrowingAlgorithm::AreClustersAssociated	(	const pandora::Cluster *const	pClusterSeed,
		const pandora::Cluster *const	pCluster
	)		const

privatevirtual

Determine whether two clusters are associated.

Parameters

pClusterSeed	address of cluster seed (may be daughter of primary seed)
pCluster	address of cluster

Returns: the association type

Implements lar_content::BranchGrowingAlgorithm.

Definition at line 276 of file ShowerGrowingAlgorithm.cc.

 {
     const VertexList *pVertexList(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pVertexList));
     const Vertex *const pVertex(
         ((pVertexList->size() == 1) && (VERTEX_3D == (*(pVertexList->begin()))->GetVertexType())) ? *(pVertexList->begin()) : nullptr);
 
     // Direction of seed cluster (cache for efficiency)
     ClusterDirectionMap::const_iterator seedIter = m_clusterDirectionMap.find(pClusterSeed);
 
     if (m_clusterDirectionMap.end() == seedIter)
     {
         const LArVertexHelper::ClusterDirection direction((nullptr == pVertex) ? LArVertexHelper::DIRECTION_UNKNOWN
                                                                                : LArVertexHelper::GetClusterDirectionInZ(this->GetPandora(), pVertex,
                                                                                      pClusterSeed, m_directionTanAngle, m_directionApexShift));
         seedIter = m_clusterDirectionMap.insert(ClusterDirectionMap::value_type(pClusterSeed, direction)).first;
     }
 
     const LArVertexHelper::ClusterDirection seedDirection(seedIter->second);
     const bool checkSeedForward(seedDirection != LArVertexHelper::DIRECTION_BACKWARD_IN_Z);
     const bool checkSeedBackward(seedDirection != LArVertexHelper::DIRECTION_FORWARD_IN_Z);
 
     // Direction of candidate cluster (cache for efficiency)
     ClusterDirectionMap::const_iterator candIter = m_clusterDirectionMap.find(pCluster);
 
     if (m_clusterDirectionMap.end() == candIter)
     {
         const LArVertexHelper::ClusterDirection direction((nullptr == pVertex) ? LArVertexHelper::DIRECTION_UNKNOWN
                                                                                : LArVertexHelper::GetClusterDirectionInZ(this->GetPandora(), pVertex,
                                                                                      pCluster, m_directionTanAngle, m_directionApexShift));
         candIter = m_clusterDirectionMap.insert(ClusterDirectionMap::value_type(pCluster, direction)).first;
     }
 
     const LArVertexHelper::ClusterDirection candidateDirection(candIter->second);
     const bool checkCandidateForward(candidateDirection != LArVertexHelper::DIRECTION_BACKWARD_IN_Z);
     const bool checkCandidateBackward(candidateDirection != LArVertexHelper::DIRECTION_FORWARD_IN_Z);
 
     // Calculate distances of association
     const float sOuter(LArClusterHelper::GetClosestDistance(pClusterSeed->GetCentroid(pClusterSeed->GetOuterPseudoLayer()), pCluster));
     const float cOuter(LArClusterHelper::GetClosestDistance(pCluster->GetCentroid(pCluster->GetOuterPseudoLayer()), pClusterSeed));
     const float sInner(LArClusterHelper::GetClosestDistance(pClusterSeed->GetCentroid(pClusterSeed->GetInnerPseudoLayer()), pCluster));
     const float cInner(LArClusterHelper::GetClosestDistance(pCluster->GetCentroid(pCluster->GetInnerPseudoLayer()), pClusterSeed));
 
     // Association check 1(a), look for enclosed clusters
     if ((cOuter < m_nearbyClusterDistance && cInner < m_nearbyClusterDistance) &&
         (!checkSeedForward || (sInner > m_nearbyClusterDistance)) && (!checkSeedBackward || (sOuter > m_nearbyClusterDistance)))
     {
         return STRONG;
     }
 
     // Association check 1(b), look for overlapping clusters
     if ((checkSeedForward == checkCandidateForward) && (checkSeedBackward == checkCandidateBackward))
     {
         if ((cInner < m_nearbyClusterDistance && sOuter < m_nearbyClusterDistance) &&
             (!checkSeedForward || (sInner > m_nearbyClusterDistance)) && (!checkSeedBackward || (cOuter > m_nearbyClusterDistance)))
         {
             return STRONG;
         }
 
         if ((cOuter < m_nearbyClusterDistance && sInner < m_nearbyClusterDistance) &&
             (!checkSeedBackward || (sOuter > m_nearbyClusterDistance)) && (!checkSeedForward || (cInner > m_nearbyClusterDistance)))
         {
             return STRONG;
         }
     }
 
     // Association check 2, look for branching clusters
     if ((!checkSeedForward || (sInner > m_remoteClusterDistance)) && (!checkSeedBackward || (sOuter > m_remoteClusterDistance)) &&
         ((checkCandidateForward && (cInner < m_nearbyClusterDistance)) || (checkCandidateBackward && (cOuter < m_nearbyClusterDistance))))
     {
         return STANDARD;
     }
 
     // Association check 3, look any distance below threshold
     if ((sOuter < m_nearbyClusterDistance) || (cOuter < m_nearbyClusterDistance) || (sInner < m_nearbyClusterDistance) || (cInner < m_nearbyClusterDistance))
         return SINGLE_ORDER;
 
     return NONE;
 }

void lar_content::ShowerGrowingAlgorithm::GetAllVertexSeedCandidates	(	const pandora::ClusterList *const	pClusterList,
		const pandora::Vertex *const	pVertex,
		pandora::ClusterVector &	seedClusters
	)		const

private

Get all seed candidates associated with a provided vertex.

Parameters

pClusterList	the list of available seed candidates
pVertex	the address of the vertex
seedClusters	to receive the list of vertex seed candidates

Definition at line 164 of file ShowerGrowingAlgorithm.cc.

 {
     ClusterVector clusterVector;
     clusterVector.insert(clusterVector.end(), pClusterList->begin(), pClusterList->end());
 
     if (clusterVector.empty())
         return;
 
     const HitType hitType(LArClusterHelper::GetClusterHitType(clusterVector.at(0)));
     const CartesianVector vertexPosition2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType));
 
     for (const Cluster *const pCluster : clusterVector)
     {
         if (!pCluster->IsAvailable())
             continue;
 
         if (MU_MINUS == std::abs(pCluster->GetParticleId()))
             continue;
 
         if (pCluster->GetNCaloHits() < m_minCaloHitsPerCluster)
             continue;
 
         try
         {
             if (this->IsVertexAssociated(LArPointingCluster(pCluster), vertexPosition2D))
                 seedClusters.push_back(pCluster);
         }
         catch (StatusCodeException &)
         {
         }
     }
 
     std::sort(seedClusters.begin(), seedClusters.end(), ShowerGrowingAlgorithm::SortClusters);
 }

float lar_content::ShowerGrowingAlgorithm::GetFigureOfMerit ( const SeedAssociationList & seedAssociationList ) const

private

Get a figure of merit representing the consistency of the provided seed associated list.

Parameters

seedAssociationList the seed association list

Returns: the figure of merit

Definition at line 358 of file ShowerGrowingAlgorithm.cc.

 {
     const VertexList *pVertexList(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pVertexList));
     const Vertex *const pVertex(
         ((pVertexList->size() == 1) && (VERTEX_3D == (*(pVertexList->begin()))->GetVertexType())) ? *(pVertexList->begin()) : nullptr);
 
     // ATTN Consistently returning same value will accept all candidate cluster merges
     if (!pVertex)
         return -1.f;
 
     unsigned int nVertexAssociatedSeeds(0), nVertexAssociatedNonSeeds(0);
 
     ClusterList clusterList;
     for (const auto &mapEntry : seedAssociationList)
         clusterList.push_back(mapEntry.first);
     clusterList.sort(LArClusterHelper::SortByNHits);
 
     for (const Cluster *const pSeedCluster : clusterList)
     {
         const ClusterVector &associatedClusters(seedAssociationList.at(pSeedCluster));
         const HitType hitType(LArClusterHelper::GetClusterHitType(pSeedCluster));
         const CartesianVector vertex2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType));
 
         LArPointingClusterList pointingClusterSeedList;
         try
         {
             pointingClusterSeedList.push_back(LArPointingCluster(pSeedCluster));
         }
         catch (StatusCodeException &)
         {
         }
 
         LArPointingClusterList pointingClusterNonSeedList;
         for (const Cluster *const pAssociatedCluster : associatedClusters)
         {
             try
             {
                 pointingClusterNonSeedList.push_back(LArPointingCluster(pAssociatedCluster));
             }
             catch (StatusCodeException &)
             {
             }
         }
 
         nVertexAssociatedSeeds += this->GetNVertexConnections(vertex2D, pointingClusterSeedList);
         nVertexAssociatedNonSeeds += this->GetNVertexConnections(vertex2D, pointingClusterNonSeedList);
     }
 
     const float figureOfMerit(static_cast<float>(nVertexAssociatedSeeds) - static_cast<float>(nVertexAssociatedNonSeeds));
     return figureOfMerit;
 }

bool lar_content::ShowerGrowingAlgorithm::GetNextSeedCandidate	(	const pandora::ClusterList *const	pClusterList,
		const pandora::ClusterSet &	usedClusters,
		const pandora::Cluster *&	pSeedCluster
	)		const

private

Get the next seed candidate, using a list of available candidates and a list of those already used.

Parameters

pClusterList	the list of available seed candidates
usedClusters	the list of candidates already considered
pSeedCluster	to receive the address of the next seed candidate

Returns: whether a seed candidate has been found

Definition at line 133 of file ShowerGrowingAlgorithm.cc.

 {
     pSeedCluster = nullptr;
 
     ClusterVector clusterVector;
     clusterVector.insert(clusterVector.end(), pClusterList->begin(), pClusterList->end());
     std::sort(clusterVector.begin(), clusterVector.end(), ShowerGrowingAlgorithm::SortClusters);
 
     for (const Cluster *const pCluster : clusterVector)
     {
         if (!pCluster->IsAvailable())
             continue;
 
         if (MU_MINUS == std::abs(pCluster->GetParticleId()))
             continue;
 
         if (pCluster->GetNCaloHits() < m_minCaloHitsPerCluster)
             continue;
 
         if (usedClusters.count(pCluster))
             continue;
 
         pSeedCluster = pCluster;
         return true;
     }
 
     return false;
 }

unsigned int lar_content::ShowerGrowingAlgorithm::GetNVertexConnections	(	const pandora::CartesianVector &	vertexPosition2D,
		const LArPointingClusterList &	pointingClusterList
	)		const

private

Get the number of clusters associated with the vertex.

Parameters

vertexPosition2D	the projected vertex position
pointingClusterList	the list of relevant pointing clusters

Returns: the number of clusters associated with the vertex

Definition at line 413 of file ShowerGrowingAlgorithm.cc.

 {
     unsigned int nConnections(0);
 
     for (LArPointingClusterList::const_iterator cIter = pointingClusterList.begin(), cIterEnd = pointingClusterList.end(); cIter != cIterEnd; ++cIter)
     {
         if (this->IsVertexAssociated(*cIter, vertexPosition2D))
             ++nConnections;
     }
 
     return nConnections;
 }

void lar_content::ShowerGrowingAlgorithm::GetSeedAssociationList	(	const pandora::ClusterVector &	particleSeedVector,
		const pandora::ClusterList *const	pClusterList,
		SeedAssociationList &	seedAssociationList
	)		const

private

Get the seed association list for a given vector of particle seed candidates.

Parameters

particleSeedVector	the particle seed vector
pClusterList	the address of the input cluster list
seedAssociationList	to receive the populated seed association list

Definition at line 201 of file ShowerGrowingAlgorithm.cc.

 {
     if (particleSeedVector.empty())
         return;
 
     ClusterVector candidateClusters;
     const ClusterList clusterList(*pClusterList);
 
     for (const Cluster *const pCandidateCluster : clusterList)
     {
         if (!pCandidateCluster->IsAvailable())
             continue;
 
         if (MU_MINUS == std::abs(pCandidateCluster->GetParticleId()))
             continue;
 
         if (pCandidateCluster->GetNCaloHits() < m_minCaloHitsPerCluster)
             continue;
 
         if (particleSeedVector.end() == std::find(particleSeedVector.begin(), particleSeedVector.end(), pCandidateCluster))
             candidateClusters.push_back(pCandidateCluster);
     }
 
     std::sort(candidateClusters.begin(), candidateClusters.end(), ShowerGrowingAlgorithm::SortClusters);
     ClusterUsageMap forwardUsageMap, backwardUsageMap;
 
     for (const Cluster *const pSeedCluster : particleSeedVector)
     {
         this->FindAssociatedClusters(pSeedCluster, candidateClusters, forwardUsageMap, backwardUsageMap);
     }
 
     this->IdentifyClusterMerges(particleSeedVector, backwardUsageMap, seedAssociationList);
 }

bool lar_content::ShowerGrowingAlgorithm::IsVertexAssociated	(	const LArPointingCluster &	pointingCluster,
		const pandora::CartesianVector &	vertexPosition2D
	)		const

protected

Whether a pointing cluster is assciated with a provided 2D vertex projection.

Parameters

pointingCluster	the pointing cluster
vertexPosition2D	the projected vertex position

Returns: boolean

Definition at line 40 of file ShowerGrowingAlgorithm.cc.

 {
     return (LArPointingClusterHelper::IsNode(vertexPosition2D, pointingCluster.GetInnerVertex(), m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
             LArPointingClusterHelper::IsNode(vertexPosition2D, pointingCluster.GetOuterVertex(), m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
             LArPointingClusterHelper::IsEmission(vertexPosition2D, pointingCluster.GetInnerVertex(), m_minVertexLongitudinalDistance,
                 m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance) ||
             LArPointingClusterHelper::IsEmission(vertexPosition2D, pointingCluster.GetOuterVertex(), m_minVertexLongitudinalDistance,
                 m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance));
 }

void lar_content::ShowerGrowingAlgorithm::ProcessBranchClusters	(	const pandora::Cluster *const	pParentCluster,
		const pandora::ClusterVector &	branchClusters,
		const std::string &	listName
	)		const

private

Process the list of branch clusters, merging with specified parent cluster, dealing with any existing pfos as required.

Parameters

pParentCluster	the address of the parent cluster
branchClusters	the list of branch clusters for the specified seed cluster
listName	the cluster list name
pfoList	the input pfo list

Definition at line 258 of file ShowerGrowingAlgorithm.cc.

 {
     m_clusterDirectionMap.erase(pParentCluster);
 
     for (const Cluster *const pBranchCluster : branchClusters)
     {
         if (pBranchCluster->IsAvailable())
         {
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
                 PandoraContentApi::MergeAndDeleteClusters(*this, pParentCluster, pBranchCluster, listName, listName));
         }
 
         m_clusterDirectionMap.erase(pBranchCluster);
     }
 }

void lar_content::ShowerGrowingAlgorithm::ProcessSeedAssociationDetails	(	const SeedAssociationList &	seedAssociationList,
		const std::string &	clusterListName,
		pandora::ClusterSet &	usedClusters
	)		const

private

Process the details stored in a specified seed association list.

Parameters

seedAssociationList	the seed association list
clusterListName	the cluster list name
pfoList	the pfo list
usedClusters	the list of candidates already considered

Definition at line 238 of file ShowerGrowingAlgorithm.cc.

 {
     ClusterList clusterList;
     for (const auto &mapEntry : seedAssociationList)
         clusterList.push_back(mapEntry.first);
     clusterList.sort(LArClusterHelper::SortByNHits);
 
     for (const Cluster *const pParentCluster : clusterList)
     {
         const ClusterVector &branchClusters(seedAssociationList.at(pParentCluster));
         this->ProcessBranchClusters(pParentCluster, branchClusters, clusterListName);
 
         usedClusters.insert(pParentCluster);
         usedClusters.insert(branchClusters.begin(), branchClusters.end());
     }
 }

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

privatevirtual

Reimplemented from lar_content::BranchGrowingAlgorithm.

Definition at line 428 of file ShowerGrowingAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "InputClusterListNames", m_inputClusterListNames));
 
     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, "NearbyClusterDistance", m_nearbyClusterDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "RemoteClusterDistance", m_remoteClusterDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DirectionTanAngle", m_directionTanAngle));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DirectionApexShift", m_directionApexShift));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinVertexLongitudinalDistance", m_minVertexLongitudinalDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxVertexLongitudinalDistance", m_maxVertexLongitudinalDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxVertexTransverseDistance", m_maxVertexTransverseDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VertexAngularAllowance", m_vertexAngularAllowance));
 
     return BranchGrowingAlgorithm::ReadSettings(xmlHandle);
 }

StatusCode lar_content::ShowerGrowingAlgorithm::Run ( )

private

Definition at line 67 of file ShowerGrowingAlgorithm.cc.

 {
     for (const std::string &clusterListName : m_inputClusterListNames)
     {
         try
         {
             const ClusterList *pClusterList = nullptr;
             PANDORA_RETURN_RESULT_IF_AND_IF(
                 STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, clusterListName, pClusterList));
 
             if (!pClusterList || pClusterList->empty())
             {
                 if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
                     std::cout << "ShowerGrowingAlgorithm: unable to find cluster list " << clusterListName << std::endl;
 
                 continue;
             }
 
             this->SimpleModeShowerGrowing(pClusterList, clusterListName);
             m_clusterDirectionMap.clear();
         }
         catch (StatusCodeException &statusCodeException)
         {
             m_clusterDirectionMap.clear();
             throw statusCodeException;
         }
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ShowerGrowingAlgorithm::SimpleModeShowerGrowing	(	const pandora::ClusterList *const	pClusterList,
		const std::string &	clusterListName
	)		const

private

Simple single-pass shower growing mode.

Parameters

pClusterList	the list of clusters
clusterListName	the cluster list name

Definition at line 100 of file ShowerGrowingAlgorithm.cc.

 {
     const VertexList *pVertexList(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pVertexList));
     const Vertex *const pVertex(
         ((pVertexList->size() == 1) && (VERTEX_3D == (*(pVertexList->begin()))->GetVertexType())) ? *(pVertexList->begin()) : nullptr);
 
     ClusterSet usedClusters;
 
     // Pick up all showers starting at vertex
     if (pVertex)
     {
         ClusterVector seedClusters;
         this->GetAllVertexSeedCandidates(pClusterList, pVertex, seedClusters);
 
         SeedAssociationList vertexSeedAssociationList;
         this->GetSeedAssociationList(seedClusters, pClusterList, vertexSeedAssociationList);
         this->ProcessSeedAssociationDetails(vertexSeedAssociationList, clusterListName, usedClusters);
     }
 
     // Non-vertex showers
     const Cluster *pSeedCluster(nullptr);
 
     while (this->GetNextSeedCandidate(pClusterList, usedClusters, pSeedCluster))
     {
         SeedAssociationList seedAssociationList;
         this->GetSeedAssociationList(ClusterVector(1, pSeedCluster), pClusterList, seedAssociationList);
         this->ProcessSeedAssociationDetails(seedAssociationList, clusterListName, usedClusters);
     }
 }

bool lar_content::ShowerGrowingAlgorithm::SortClusters	(	const pandora::Cluster *const	pLhs,
		const pandora::Cluster *const	pRhs
	)

staticprotected

Sorting for clusters to determine order in which seeds are considered.

Parameters

pLhs	address of first cluster
pRhs	address of second cluster

Definition at line 52 of file ShowerGrowingAlgorithm.cc.

 {
     CartesianVector innerCoordinateLhs(0.f, 0.f, 0.f), outerCoordinateLhs(0.f, 0.f, 0.f);
     LArClusterHelper::GetExtremalCoordinates(pLhs, innerCoordinateLhs, outerCoordinateLhs);
     const float dLhs2((outerCoordinateLhs - innerCoordinateLhs).GetMagnitudeSquared());
 
     CartesianVector innerCoordinateRhs(0.f, 0.f, 0.f), outerCoordinateRhs(0.f, 0.f, 0.f);
     LArClusterHelper::GetExtremalCoordinates(pRhs, innerCoordinateRhs, outerCoordinateRhs);
     const float dRhs2((outerCoordinateRhs - innerCoordinateRhs).GetMagnitudeSquared());
 
     return (dLhs2 > dRhs2);
 }

Member Data Documentation

ClusterDirectionMap lar_content::ShowerGrowingAlgorithm::m_clusterDirectionMap

mutableprotected

The cluster direction map.

Definition at line 55 of file ShowerGrowingAlgorithm.h.

float lar_content::ShowerGrowingAlgorithm::m_directionApexShift

private

Direction determination, look for vertex inside triangle with apex shifted along the cluster length.

Definition at line 152 of file ShowerGrowingAlgorithm.h.

float lar_content::ShowerGrowingAlgorithm::m_directionTanAngle

private

Direction determination, look for vertex inside triangle with apex shifted along the cluster length.

Definition at line 151 of file ShowerGrowingAlgorithm.h.

pandora::StringVector lar_content::ShowerGrowingAlgorithm::m_inputClusterListNames

private

The names of the input cluster lists.

Definition at line 145 of file ShowerGrowingAlgorithm.h.

float lar_content::ShowerGrowingAlgorithm::m_maxVertexLongitudinalDistance

private

Vertex association check: max longitudinal distance cut.

Definition at line 155 of file ShowerGrowingAlgorithm.h.

float lar_content::ShowerGrowingAlgorithm::m_maxVertexTransverseDistance

private

Vertex association check: max transverse distance cut.

Definition at line 156 of file ShowerGrowingAlgorithm.h.

unsigned int lar_content::ShowerGrowingAlgorithm::m_minCaloHitsPerCluster

private

The minimum number of calo hits per (seed or branch) cluster.

Definition at line 147 of file ShowerGrowingAlgorithm.h.

float lar_content::ShowerGrowingAlgorithm::m_minVertexLongitudinalDistance

private

Vertex association check: min longitudinal distance cut.

Definition at line 154 of file ShowerGrowingAlgorithm.h.

float lar_content::ShowerGrowingAlgorithm::m_nearbyClusterDistance

private

The nearby cluster distance, used for determining cluster associations.

Definition at line 148 of file ShowerGrowingAlgorithm.h.

float lar_content::ShowerGrowingAlgorithm::m_remoteClusterDistance

private

The remote cluster distance, used for determining cluster associations.

Definition at line 149 of file ShowerGrowingAlgorithm.h.

float lar_content::ShowerGrowingAlgorithm::m_vertexAngularAllowance

private

Vertex association check: pointing angular allowance in degrees.

Definition at line 157 of file ShowerGrowingAlgorithm.h.

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

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation