TransverseAssociationAlgorithm class. More...

#include <TransverseAssociationAlgorithm.h>

Inheritance diagram for lar_content::TransverseAssociationAlgorithm:

Classes
class	LArTransverseCluster
	LArTransverseCluster class. More...

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

Public Member Functions inherited from lar_content::ClusterAssociationAlgorithm
	ClusterAssociationAlgorithm ()
	Default constructor. More...

Private Types
typedef std::vector < LArTransverseCluster * >	TransverseClusterList

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::ClusterSet >	ClusterToClustersMap

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

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

void	GetListOfCleanClusters (const pandora::ClusterList *const pClusterList, pandora::ClusterVector &clusterVector) const
	Populate cluster vector with subset of cluster list, containing clusters judged to be clean. More...

void	PopulateClusterAssociationMap (const pandora::ClusterVector &clusterVector, ClusterAssociationMap &clusterAssociationMap) const
	Populate the cluster association map. More...

bool	IsExtremalCluster (const bool isForward, const pandora::Cluster const pCurrentCluster, const pandora::Cluster const pTestCluster) const
	Determine which of two clusters is extremal. More...

void	GetNearbyClusterMap (const pandora::ClusterVector &allClusters, ClusterToClustersMap &nearbyClusters) const
	Use a kd-tree to obtain details of all nearby cluster combinations. More...

void	SortInputClusters (const pandora::ClusterVector &inputClusters, pandora::ClusterVector &shortClusters, pandora::ClusterVector &transverseMediumClusters, pandora::ClusterVector &longitudinalMediumClusters, pandora::ClusterVector &longClusters) const
	Separate input clusters by length. More...

void	FillReducedAssociationMap (const ClusterToClustersMap &nearbyClusters, const pandora::ClusterVector &firstVector, const pandora::ClusterVector &secondVector, ClusterAssociationMap &clusterAssociationMap) const
	Form a reduced set of associations between two input lists of clusters. More...

void	FillAssociationMap (const ClusterToClustersMap &nearbyClusters, const pandora::ClusterVector &firstVector, const pandora::ClusterVector &secondVector, ClusterAssociationMap &firstAssociationMap, ClusterAssociationMap &secondAssociationMap) const
	Form associations between two input lists of cluster. More...

void	FillTransverseClusterList (const ClusterToClustersMap &nearbyClusters, const pandora::ClusterVector &inputClusters, const ClusterAssociationMap &inputAssociationMap, TransverseClusterList &transverseClusterList) const
	Create transverse cluster objects, these are protoclusters with a direction and inner/outer vertices. More...

void	FillTransverseAssociationMap (const ClusterToClustersMap &nearbyClusters, const TransverseClusterList &transverseClusterList, const ClusterAssociationMap &transverseAssociationMap, ClusterAssociationMap &clusterAssociationMap) const
	Form associations between transverse cluster objects. More...

void	GetAssociatedClusters (const ClusterToClustersMap &nearbyClusters, const pandora::Cluster *const pCluster, const ClusterAssociationMap &inputAssociationMap, pandora::ClusterVector &associatedClusters) const
	Find the clusters that are transversely associated with a target cluster. More...

bool	IsAssociated (const bool isForward, const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, const ClusterToClustersMap &nearbyClusters) const
	Determine whether clusters are association. More...

bool	IsTransverseAssociated (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, const ClusterToClustersMap &nearbyClusters) const
	Determine whether two clusters are within the same cluster window. More...

bool	IsTransverseAssociated (const LArTransverseCluster const pTransverseCluster1, const LArTransverseCluster const pTransverseCluster2, const ClusterToClustersMap &nearbyClusters) const
	Determine whether two transverse clusters are associated. More...

bool	IsTransverseAssociated (const LArTransverseCluster *const pTransverseCluster, const pandora::CartesianVector &testPosition) const
	Determine whether one transverse cluster is associated with the vertex from a second transverse cluster. More...

bool	IsOverlapping (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2) const
	Determine whether two clusters are overlapping. More...

float	GetTransverseSpan (const pandora::Cluster *const pCluster) const
	Calculate the overall span in X for a clusters. More...

float	GetLongitudinalSpan (const pandora::Cluster *const pCluster) const
	Calculate the overall span in Z for a clusters. More...

float	GetTransverseSpan (const pandora::Cluster *const pCluster, const pandora::ClusterVector &associatedClusters) const
	Calculate the overall span in X for a set of clusters. More...

void	GetExtremalCoordinatesX (const pandora::Cluster *const pCluster, float &minX, float &maxX) const
	Get minimum and maximum X coordinates for a given cluster. More...

void	GetExtremalCoordinatesZ (const pandora::Cluster *const pCluster, float &minZ, float &maxZ) const
	Get minimum and maximum Z coordinates for a given cluster. More...

void	GetExtremalCoordinatesXZ (const pandora::Cluster *const pCluster, const bool useX, float &minXZ, float &maxXZ) const
	Get minimum and maximum X or Z coordinates for a given cluster. More...

void	GetExtremalCoordinatesX (const pandora::Cluster *const pCluster, pandora::CartesianVector &innerCoordinate, pandora::CartesianVector &outerCoordinate) const
	Get extremal 2D coordinates for a given cluster (ordered by X) More...

void	FillReducedAssociationMap (const ClusterAssociationMap &inputAssociationMap, ClusterAssociationMap &outputAssociationMap) const
	Remove double-counting from association map. More...

void	FillReducedAssociationMap (const ClusterAssociationMap &firstAssociationMap, const ClusterAssociationMap &secondAssociationMap, const ClusterAssociationMap &secondAssociationMapSwapped, ClusterAssociationMap &clusterAssociationMap) const
	Use one map to block associations from another map. More...

void	FillSymmetricAssociationMap (const ClusterAssociationMap &inputAssociationMap, ClusterAssociationMap &outputAssociationMap) const
	Symmetrise an association map. More...

void	FinalizeClusterAssociationMap (const ClusterAssociationMap &inputAssociationMap, ClusterAssociationMap &outputAssociationMap) const
	Symmetrise and then remove double-counting from an association map. More...

Private Attributes
float	m_firstLengthCut

float	m_secondLengthCut

float	m_clusterWindow

float	m_clusterAngle

float	m_clusterCosAngle

float	m_clusterTanAngle

float	m_maxTransverseOverlap

float	m_maxProjectedOverlap

float	m_maxLongitudinalOverlap

float	m_transverseClusterMinCosTheta

float	m_transverseClusterMinLength

float	m_transverseClusterMaxDisplacement

float	m_searchRegionX
	Search region, applied to x dimension, for look-up from kd-trees. More...

float	m_searchRegionZ
	Search region, applied to u/v/w dimension, for look-up from kd-trees. More...

Additional Inherited Members
Protected Types inherited from lar_content::ClusterAssociationAlgorithm
typedef std::unordered_map < const pandora::Cluster *, ClusterAssociation >	ClusterAssociationMap

Protected Member Functions inherited from lar_content::ClusterAssociationAlgorithm
virtual pandora::StatusCode	Run ()

Detailed Description

TransverseAssociationAlgorithm class.

Definition at line 28 of file TransverseAssociationAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, pandora::ClusterSet> lar_content::TransverseAssociationAlgorithm::ClusterToClustersMap

private

Definition at line 100 of file TransverseAssociationAlgorithm.h.

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

private

Definition at line 97 of file TransverseAssociationAlgorithm.h.

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

private

Definition at line 98 of file TransverseAssociationAlgorithm.h.

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

private

Definition at line 96 of file TransverseAssociationAlgorithm.h.

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

private

Definition at line 101 of file TransverseAssociationAlgorithm.h.

typedef std::vector<LArTransverseCluster *> lar_content::TransverseAssociationAlgorithm::TransverseClusterList

private

Definition at line 94 of file TransverseAssociationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::TransverseAssociationAlgorithm::TransverseAssociationAlgorithm ( )

Default constructor.

Definition at line 22 of file TransverseAssociationAlgorithm.cc.

                                                                :
     m_firstLengthCut(1.5f),
     m_secondLengthCut(7.5f),
     m_clusterWindow(3.f),
     m_clusterAngle(45.f),
     m_clusterCosAngle(std::cos(m_clusterAngle * M_PI / 180.f)),
     m_clusterTanAngle(std::tan(m_clusterAngle * M_PI / 180.f)),
     m_maxTransverseOverlap(0.5f),
     m_maxProjectedOverlap(1.f),
     m_maxLongitudinalOverlap(1.5f),
     m_transverseClusterMinCosTheta(0.866f),
     m_transverseClusterMinLength(0.5f),
     m_transverseClusterMaxDisplacement(1.5f),
     m_searchRegionX(3.5f),
     m_searchRegionZ(2.f)
 {
 }

Member Function Documentation

void lar_content::TransverseAssociationAlgorithm::FillAssociationMap	(	const ClusterToClustersMap &	nearbyClusters,
		const pandora::ClusterVector &	firstVector,
		const pandora::ClusterVector &	secondVector,
		ClusterAssociationMap &	firstAssociationMap,
		ClusterAssociationMap &	secondAssociationMap
	)		const

private

Form associations between two input lists of cluster.

Parameters

nearbyClusters	the nearby cluster map, extracted via use of a kd-tree
firstVector	the first input vector of clusters
secondVector	the second input vector of clusters
firstAssociationMap	the map of associations between first and second cluster vectors
secondAssociationMap	the reversed map of associations between first and cluster vectors

Definition at line 212 of file TransverseAssociationAlgorithm.cc.

 {
     for (ClusterVector::const_iterator iterI = firstVector.begin(), iterEndI = firstVector.end(); iterI != iterEndI; ++iterI)
     {
         const Cluster *const pClusterI = *iterI;
 
         for (ClusterVector::const_iterator iterJ = secondVector.begin(), iterEndJ = secondVector.end(); iterJ != iterEndJ; ++iterJ)
         {
             const Cluster *const pClusterJ = *iterJ;
 
             if (pClusterI == pClusterJ)
                 continue;
 
             if (this->IsAssociated(true, pClusterI, pClusterJ, nearbyClusters))
             {
                 firstAssociationMap[pClusterI].m_forwardAssociations.insert(pClusterJ);
                 secondAssociationMap[pClusterJ].m_backwardAssociations.insert(pClusterI);
             }
 
             if (this->IsAssociated(false, pClusterI, pClusterJ, nearbyClusters))
             {
                 firstAssociationMap[pClusterI].m_backwardAssociations.insert(pClusterJ);
                 secondAssociationMap[pClusterJ].m_forwardAssociations.insert(pClusterI);
             }
         }
     }
 }

void lar_content::TransverseAssociationAlgorithm::FillReducedAssociationMap	(	const ClusterToClustersMap &	nearbyClusters,
		const pandora::ClusterVector &	firstVector,
		const pandora::ClusterVector &	secondVector,
		ClusterAssociationMap &	clusterAssociationMap
	)		const

private

Form a reduced set of associations between two input lists of clusters.

Parameters

nearbyClusters	the nearby cluster map, extracted via use of a kd-tree
firstVector	the first input vector of clusters
secondVector	the second input vector of clusters
clusterAssociationMap	the output map of associations between clusters

void lar_content::TransverseAssociationAlgorithm::FillReducedAssociationMap	(	const ClusterAssociationMap &	inputAssociationMap,
		ClusterAssociationMap &	outputAssociationMap
	)		const

private

Remove double-counting from association map.

Parameters

inputAssociationMap	the inputted association map
outputAssociationMap	the outputted association map

Definition at line 592 of file TransverseAssociationAlgorithm.cc.

 {
     return this->FillReducedAssociationMap(inputAssociationMap, inputAssociationMap, inputAssociationMap, outputAssociationMap);
 }

void lar_content::TransverseAssociationAlgorithm::FillReducedAssociationMap	(	const ClusterAssociationMap &	firstAssociationMap,
		const ClusterAssociationMap &	secondAssociationMap,
		const ClusterAssociationMap &	secondAssociationMapSwapped,
		ClusterAssociationMap &	clusterAssociationMap
	)		const

private

Use one map to block associations from another map.

Parameters

firstAssociationMap	the first association map
secondAssociationMap	the second association map
secondAssociationMap	the second association map reversed
clusterAssociationMap	the outputted association map

Definition at line 600 of file TransverseAssociationAlgorithm.cc.

 {
     // Remove associations A->B from the first association map
     // if A->C exists in the second map and C->B exists in the reversed second map
 
     // Method can also be accessed through FillReducedAssociationMap(input,output) method,
     // which will remove association A->B from the input map if an association A->C and C->B
     // already exists in the map.
 
     ClusterVector sortedClusters;
     for (const auto &mapEntry : firstAssociationMap)
         sortedClusters.push_back(mapEntry.first);
     std::sort(sortedClusters.begin(), sortedClusters.end(), LArClusterHelper::SortByNHits);
 
     for (const Cluster *const pCluster : sortedClusters)
     {
         const ClusterAssociation &firstAssociation(firstAssociationMap.at(pCluster));
 
         ClusterVector sortedOuterClusters(firstAssociation.m_forwardAssociations.begin(), firstAssociation.m_forwardAssociations.end());
         std::sort(sortedOuterClusters.begin(), sortedOuterClusters.end(), LArClusterHelper::SortByNHits);
 
         ClusterVector sortedInnerClusters(firstAssociation.m_backwardAssociations.begin(), firstAssociation.m_backwardAssociations.end());
         std::sort(sortedInnerClusters.begin(), sortedInnerClusters.end(), LArClusterHelper::SortByNHits);
 
         ClusterAssociationMap::const_iterator iterSecond = secondAssociationMap.find(pCluster);
         ClusterVector sortedMiddleClustersF, sortedMiddleClustersB;
 
         if (secondAssociationMap.end() != iterSecond)
         {
             sortedMiddleClustersF.insert(sortedMiddleClustersF.end(), iterSecond->second.m_forwardAssociations.begin(),
                 iterSecond->second.m_forwardAssociations.end());
             sortedMiddleClustersB.insert(sortedMiddleClustersB.end(), iterSecond->second.m_backwardAssociations.begin(),
                 iterSecond->second.m_backwardAssociations.end());
             std::sort(sortedMiddleClustersF.begin(), sortedMiddleClustersF.end(), LArClusterHelper::SortByNHits);
             std::sort(sortedMiddleClustersB.begin(), sortedMiddleClustersB.end(), LArClusterHelper::SortByNHits);
         }
 
         for (const Cluster *const pOuterCluster : sortedOuterClusters)
         {
             bool isNeighbouringCluster(true);
 
             for (const Cluster *const pMiddleCluster : sortedMiddleClustersF)
             {
                 ClusterAssociationMap::const_iterator iterSecondCheck = secondAssociationMapSwapped.find(pMiddleCluster);
                 if (secondAssociationMapSwapped.end() == iterSecondCheck)
                     continue;
 
                 if (iterSecondCheck->second.m_forwardAssociations.count(pOuterCluster) > 0)
                 {
                     isNeighbouringCluster = false;
                     break;
                 }
             }
 
             if (isNeighbouringCluster)
                 clusterAssociationMap[pCluster].m_forwardAssociations.insert(pOuterCluster);
         }
 
         for (const Cluster *const pInnerCluster : sortedInnerClusters)
         {
             bool isNeighbouringCluster(true);
 
             for (const Cluster *const pMiddleCluster : sortedMiddleClustersB)
             {
                 ClusterAssociationMap::const_iterator iterSecondCheck = secondAssociationMapSwapped.find(pMiddleCluster);
                 if (secondAssociationMapSwapped.end() == iterSecondCheck)
                     continue;
 
                 if (iterSecondCheck->second.m_backwardAssociations.count(pInnerCluster) > 0)
                 {
                     isNeighbouringCluster = false;
                     break;
                 }
             }
 
             if (isNeighbouringCluster)
                 clusterAssociationMap[pCluster].m_backwardAssociations.insert(pInnerCluster);
         }
     }
 }

void lar_content::TransverseAssociationAlgorithm::FillSymmetricAssociationMap	(	const ClusterAssociationMap &	inputAssociationMap,
		ClusterAssociationMap &	outputAssociationMap
	)		const

private

Symmetrise an association map.

Parameters

inputAssociationMap	the inputted association map
outputAssociationMap	the outputted association map

Definition at line 685 of file TransverseAssociationAlgorithm.cc.

 {
     // Generate a symmetrised association map, so that both A--Fwd-->B and B--Bwd-->A both exist.
     // If A is associated to B through both a backward and forward association (very bad!),
     // try to rationalise this through majority voting, otherwise remove the association.
 
     ClusterVector sortedClusters;
     for (const auto &mapEntry : inputAssociationMap)
         sortedClusters.push_back(mapEntry.first);
     std::sort(sortedClusters.begin(), sortedClusters.end(), LArClusterHelper::SortByNHits);
 
     for (const Cluster *const pCluster : sortedClusters)
     {
         const ClusterAssociation &inputAssociation(inputAssociationMap.at(pCluster));
 
         ClusterVector sortedForwardClusters(inputAssociation.m_forwardAssociations.begin(), inputAssociation.m_forwardAssociations.end());
         std::sort(sortedForwardClusters.begin(), sortedForwardClusters.end(), LArClusterHelper::SortByNHits);
 
         ClusterVector sortedBackwardClusters(inputAssociation.m_backwardAssociations.begin(), inputAssociation.m_backwardAssociations.end());
         std::sort(sortedBackwardClusters.begin(), sortedBackwardClusters.end(), LArClusterHelper::SortByNHits);
 
         // Symmetrise forward associations
         for (const Cluster *const pForwardCluster : sortedForwardClusters)
         {
             int nCounter(+1);
 
             if (inputAssociation.m_backwardAssociations.count(pForwardCluster))
                 --nCounter;
 
             ClusterAssociationMap::const_iterator iterCheck = inputAssociationMap.find(pForwardCluster);
             if (inputAssociationMap.end() != iterCheck)
             {
                 if (iterCheck->second.m_forwardAssociations.count(pCluster))
                     --nCounter;
 
                 if (iterCheck->second.m_backwardAssociations.count(pCluster))
                     ++nCounter;
             }
 
             if (nCounter > 0)
             {
                 if (!(outputAssociationMap[pCluster].m_backwardAssociations.count(pForwardCluster) == 0 &&
                         outputAssociationMap[pForwardCluster].m_forwardAssociations.count(pCluster) == 0))
                     throw StatusCodeException(STATUS_CODE_FAILURE);
 
                 outputAssociationMap[pCluster].m_forwardAssociations.insert(pForwardCluster);
                 outputAssociationMap[pForwardCluster].m_backwardAssociations.insert(pCluster);
             }
         }
 
         // Symmetrise backward associations
         for (const Cluster *const pBackwardCluster : sortedBackwardClusters)
         {
             int nCounter(-1);
 
             if (inputAssociation.m_forwardAssociations.count(pBackwardCluster))
                 ++nCounter;
 
             ClusterAssociationMap::const_iterator iterCheck = inputAssociationMap.find(pBackwardCluster);
             if (inputAssociationMap.end() != iterCheck)
             {
                 if (iterCheck->second.m_backwardAssociations.count(pCluster))
                     ++nCounter;
 
                 if (iterCheck->second.m_forwardAssociations.count(pCluster))
                     --nCounter;
             }
 
             if (nCounter < 0)
             {
                 if (!(outputAssociationMap[pCluster].m_forwardAssociations.count(pBackwardCluster) == 0 &&
                         outputAssociationMap[pBackwardCluster].m_backwardAssociations.count(pCluster) == 0))
                     throw StatusCodeException(STATUS_CODE_FAILURE);
 
                 outputAssociationMap[pCluster].m_backwardAssociations.insert(pBackwardCluster);
                 outputAssociationMap[pBackwardCluster].m_forwardAssociations.insert(pCluster);
             }
         }
     }
 }

void lar_content::TransverseAssociationAlgorithm::FillTransverseAssociationMap	(	const ClusterToClustersMap &	nearbyClusters,
		const TransverseClusterList &	transverseClusterList,
		const ClusterAssociationMap &	transverseAssociationMap,
		ClusterAssociationMap &	clusterAssociationMap
	)		const

private

Form associations between transverse cluster objects.

Parameters

nearbyClusters	the nearby cluster map, extracted via use of a kd-tree
transverseClusterList	the input vector of transverse cluster objects
transverseAssociationMap	the external map of associations between clusters
clusterAssociationMap	the output map of associations between clusters

Definition at line 262 of file TransverseAssociationAlgorithm.cc.

 {
     for (TransverseClusterList::const_iterator iter1 = transverseClusterList.begin(), iterEnd1 = transverseClusterList.end(); iter1 != iterEnd1; ++iter1)
     {
         LArTransverseCluster *const pInnerTransverseCluster = *iter1;
         const Cluster *const pInnerCluster(pInnerTransverseCluster->GetSeedCluster());
 
         ClusterAssociationMap::const_iterator iterInner = transverseAssociationMap.find(pInnerCluster);
         if (transverseAssociationMap.end() == iterInner)
             continue;
 
         for (TransverseClusterList::const_iterator iter2 = transverseClusterList.begin(), iterEnd2 = transverseClusterList.end();
              iter2 != iterEnd2; ++iter2)
         {
             LArTransverseCluster *const pOuterTransverseCluster = *iter2;
             const Cluster *const pOuterCluster(pOuterTransverseCluster->GetSeedCluster());
 
             ClusterAssociationMap::const_iterator iterOuter = transverseAssociationMap.find(pOuterCluster);
             if (transverseAssociationMap.end() == iterOuter)
                 continue;
 
             if (pInnerCluster == pOuterCluster)
                 continue;
 
             if (iterInner->second.m_forwardAssociations.count(pOuterCluster) == 0 || iterOuter->second.m_backwardAssociations.count(pInnerCluster) == 0)
                 continue;
 
             if (!this->IsExtremalCluster(true, pInnerCluster, pOuterCluster) || !this->IsExtremalCluster(false, pOuterCluster, pInnerCluster))
                 continue;
 
             if (!this->IsTransverseAssociated(pInnerTransverseCluster, pOuterTransverseCluster, nearbyClusters))
                 continue;
 
             clusterAssociationMap[pInnerCluster].m_forwardAssociations.insert(pOuterCluster);
             clusterAssociationMap[pOuterCluster].m_backwardAssociations.insert(pInnerCluster);
         }
     }
 }

void lar_content::TransverseAssociationAlgorithm::FillTransverseClusterList	(	const ClusterToClustersMap &	nearbyClusters,
		const pandora::ClusterVector &	inputClusters,
		const ClusterAssociationMap &	inputAssociationMap,
		TransverseClusterList &	transverseClusterList
	)		const

private

Create transverse cluster objects, these are protoclusters with a direction and inner/outer vertices.

Parameters

nearbyClusters	the nearby cluster map, extracted via use of a kd-tree
inputClusters	the input vector of clusters
inputAssociationMap	the map of associations between input clusters
transverseClusterList	the output vector of transverse cluster objects

Definition at line 243 of file TransverseAssociationAlgorithm.cc.

 {
     for (ClusterVector::const_iterator iter = inputVector.begin(), iterEnd = inputVector.end(); iter != iterEnd; ++iter)
     {
         const Cluster *const pCluster = *iter;
         ClusterVector associatedClusters;
 
         this->GetAssociatedClusters(nearbyClusters, pCluster, inputAssociationMap, associatedClusters);
 
         if (this->GetTransverseSpan(pCluster, associatedClusters) < m_transverseClusterMinLength)
             continue;
 
         transverseClusterList.push_back(new LArTransverseCluster(pCluster, associatedClusters));
     }
 }

void lar_content::TransverseAssociationAlgorithm::FinalizeClusterAssociationMap	(	const ClusterAssociationMap &	inputAssociationMap,
		ClusterAssociationMap &	outputAssociationMap
	)		const

private

Symmetrise and then remove double-counting from an association map.

Parameters

inputAssociationMap	the inputted association map
outputAssociationMap	the outputted association map

Definition at line 769 of file TransverseAssociationAlgorithm.cc.

 {
     ClusterAssociationMap intermediateAssociationMap;
     this->FillSymmetricAssociationMap(inputAssociationMap, intermediateAssociationMap);
     this->FillReducedAssociationMap(intermediateAssociationMap, outputAssociationMap);
 }

void lar_content::TransverseAssociationAlgorithm::GetAssociatedClusters	(	const ClusterToClustersMap &	nearbyClusters,
		const pandora::Cluster *const	pCluster,
		const ClusterAssociationMap &	inputAssociationMap,
		pandora::ClusterVector &	associatedClusters
	)		const

private

Find the clusters that are transversely associated with a target cluster.

Parameters

nearbyClusters	the nearby cluster map, extracted via use of a kd-tree
pCluster	the target cluster
inputAssociationMap	the map of associations between clusters
outputClusters	the output vector of clusters transversely associated with target cluster

Definition at line 305 of file TransverseAssociationAlgorithm.cc.

 {
     ClusterAssociationMap::const_iterator iterI = associationMap.find(pClusterI);
     if (associationMap.end() == iterI)
         return;
 
     for (ClusterSet::const_iterator iterJ = iterI->second.m_forwardAssociations.begin(), iterEndJ = iterI->second.m_forwardAssociations.end();
          iterJ != iterEndJ; ++iterJ)
     {
         const Cluster *const pClusterJ = *iterJ;
 
         if (this->IsTransverseAssociated(pClusterI, pClusterJ, nearbyClusters))
             associatedVector.push_back(pClusterJ);
     }
 
     for (ClusterSet::const_iterator iterJ = iterI->second.m_backwardAssociations.begin(), iterEndJ = iterI->second.m_backwardAssociations.end();
          iterJ != iterEndJ; ++iterJ)
     {
         const Cluster *const pClusterJ = *iterJ;
 
         if (this->IsTransverseAssociated(pClusterJ, pClusterI, nearbyClusters))
             associatedVector.push_back(pClusterJ);
     }
 
     std::sort(associatedVector.begin(), associatedVector.end(), LArClusterHelper::SortByNHits);
 }

void lar_content::TransverseAssociationAlgorithm::GetExtremalCoordinatesX	(	const pandora::Cluster *const	pCluster,
		float &	minX,
		float &	maxX
	)		const

private

Get minimum and maximum X coordinates for a given cluster.

Parameters

pCluster	the input cluster
minX	the minimum X position
maxX	the maximum X position

void lar_content::TransverseAssociationAlgorithm::GetExtremalCoordinatesX	(	const pandora::Cluster *const	pCluster,
		pandora::CartesianVector &	innerCoordinate,
		pandora::CartesianVector &	outerCoordinate
	)		const

private

Get extremal 2D coordinates for a given cluster (ordered by X)

Parameters

pCluster	the input cluster
innerCoordinate	the inner coordinate
outerCoordinate	the outer coordinate

void lar_content::TransverseAssociationAlgorithm::GetExtremalCoordinatesXZ	(	const pandora::Cluster *const	pCluster,
		const bool	useX,
		float &	minXZ,
		float &	maxXZ
	)		const

private

Get minimum and maximum X or Z coordinates for a given cluster.

Parameters

pCluster	the input cluster
useX	calculate extermal coordinates for X (rather than Z)
minXZ	the minimum X or Z position
maxXZ	the maximum X or Z position

Definition at line 553 of file TransverseAssociationAlgorithm.cc.

 {
     minXZ = +std::numeric_limits<float>::max();
     maxXZ = -std::numeric_limits<float>::max();
 
     const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());
 
     for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
     {
         for (CaloHitList::const_iterator hitIter = iter->second->begin(), hitIterEnd = iter->second->end(); hitIter != hitIterEnd; ++hitIter)
         {
             const float caloHitXZ(useX ? (*hitIter)->GetPositionVector().GetX() : (*hitIter)->GetPositionVector().GetZ());
 
             if (caloHitXZ < minXZ)
                 minXZ = caloHitXZ;
 
             if (caloHitXZ > maxXZ)
                 maxXZ = caloHitXZ;
         }
     }
 
     if (maxXZ < minXZ)
         throw pandora::StatusCodeException(STATUS_CODE_FAILURE);
 }

void lar_content::TransverseAssociationAlgorithm::GetExtremalCoordinatesZ	(	const pandora::Cluster *const	pCluster,
		float &	minZ,
		float &	maxZ
	)		const

private

Get minimum and maximum Z coordinates for a given cluster.

Parameters

pCluster	the input cluster
minZ	the minimum Z position
maxZ	the maximum Z position

Definition at line 546 of file TransverseAssociationAlgorithm.cc.

 {
     return this->GetExtremalCoordinatesXZ(pCluster, false, minZ, maxZ);
 }

void lar_content::TransverseAssociationAlgorithm::GetListOfCleanClusters	(	const pandora::ClusterList *const	pClusterList,
		pandora::ClusterVector &	clusterVector
	)		const

privatevirtual

Populate cluster vector with subset of cluster list, containing clusters judged to be clean.

Parameters

pClusterList	address of the cluster list
clusterVector	to receive the populated cluster vector

Implements lar_content::ClusterAssociationAlgorithm.

Definition at line 42 of file TransverseAssociationAlgorithm.cc.

 {
     clusterVector.clear();
     clusterVector.insert(clusterVector.begin(), pClusterList->begin(), pClusterList->end());
     std::sort(clusterVector.begin(), clusterVector.end(), LArClusterHelper::SortByNHits);
 }

float lar_content::TransverseAssociationAlgorithm::GetLongitudinalSpan ( const pandora::Cluster *const pCluster ) const

private

Calculate the overall span in Z for a clusters.

Parameters

pCluster the target cluster

Definition at line 475 of file TransverseAssociationAlgorithm.cc.

 {
     float minZ(+std::numeric_limits<float>::max());
     float maxZ(-std::numeric_limits<float>::max());
 
     this->GetExtremalCoordinatesZ(pCluster, minZ, maxZ);
 
     return (maxZ - minZ);
 }

void lar_content::TransverseAssociationAlgorithm::GetNearbyClusterMap	(	const pandora::ClusterVector &	allClusters,
		ClusterToClustersMap &	nearbyClusters
	)		const

private

Use a kd-tree to obtain details of all nearby cluster combinations.

Parameters

allClusters	the list of all clusters
nearbyClusters	to obtain the nearby cluster map

Definition at line 118 of file TransverseAssociationAlgorithm.cc.

 {
     HitToClusterMap hitToClusterMap;
     CaloHitList allCaloHits;
 
     for (const Cluster *const pCluster : allClusters)
     {
         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 : allClusters)
     {
         CaloHitList daughterHits;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(daughterHits);
 
         for (const CaloHit *const pCaloHit : daughterHits)
         {
             KDTreeBox searchRegionHits(build_2d_kd_search_region(pCaloHit, m_searchRegionX, m_searchRegionZ));
 
             HitKDNode2DList found;
             kdTree.search(searchRegionHits, found);
 
             for (const auto &hit : found)
                 (void)nearbyClusters[pCluster].insert(hitToClusterMap.at(hit.data));
         }
     }
 }

float lar_content::TransverseAssociationAlgorithm::GetTransverseSpan ( const pandora::Cluster *const pCluster ) const

private

Calculate the overall span in X for a clusters.

Parameters

pCluster the target cluster

float lar_content::TransverseAssociationAlgorithm::GetTransverseSpan	(	const pandora::Cluster *const	pCluster,
		const pandora::ClusterVector &	associatedClusters
	)		const

private

Calculate the overall span in X for a set of clusters.

Parameters

pCluster	the target cluster
associatedClusters	the vector of associated clusters

bool lar_content::TransverseAssociationAlgorithm::IsAssociated	(	const bool	isForward,
		const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		const ClusterToClustersMap &	nearbyClusters
	)		const

private

Determine whether clusters are association.

Parameters

isForward	whether the association is forwards or backwards
pCluster1	the first cluster
pCluster2	the second cluster
nearbyClusters	the nearby cluster map, extracted via use of a kd-tree

Returns: boolean

Definition at line 335 of file TransverseAssociationAlgorithm.cc.

 {
     if ((0 == nearbyClusters.at(pFirstCluster).count(pSecondCluster)) || (0 == nearbyClusters.at(pSecondCluster).count(pFirstCluster)))
         return false;
 
     CartesianVector firstInner(0.f, 0.f, 0.f), firstOuter(0.f, 0.f, 0.f);
     CartesianVector secondInner(0.f, 0.f, 0.f), secondOuter(0.f, 0.f, 0.f);
     this->GetExtremalCoordinatesX(pFirstCluster, firstInner, firstOuter);
     this->GetExtremalCoordinatesX(pSecondCluster, secondInner, secondOuter);
 
     const CartesianVector firstCoordinate(isForward ? firstOuter : firstInner);
     const CartesianVector secondCoordinate(isForward ? secondOuter : secondInner);
 
     if ((firstCoordinate.GetZ() > std::max(secondInner.GetZ(), secondOuter.GetZ()) + m_maxLongitudinalOverlap) ||
         (firstCoordinate.GetZ() < std::min(secondInner.GetZ(), secondOuter.GetZ()) - m_maxLongitudinalOverlap))
         return false;
 
     if ((isForward && secondCoordinate.GetX() < firstCoordinate.GetX()) || (!isForward && secondCoordinate.GetX() > firstCoordinate.GetX()))
         return false;
 
     const CartesianVector firstProjection(LArClusterHelper::GetClosestPosition(firstCoordinate, pSecondCluster));
 
     if ((isForward && firstProjection.GetX() < firstCoordinate.GetX() - m_maxTransverseOverlap) ||
         (!isForward && firstProjection.GetX() > firstCoordinate.GetX() + m_maxTransverseOverlap))
         return false;
 
     if ((isForward && firstProjection.GetX() > firstCoordinate.GetX() + m_clusterWindow) ||
         (!isForward && firstProjection.GetX() < firstCoordinate.GetX() - m_clusterWindow))
         return false;
 
     return true;
 }

bool lar_content::TransverseAssociationAlgorithm::IsExtremalCluster	(	const bool	isForward,
		const pandora::Cluster *const	pCurrentCluster,
		const pandora::Cluster *const	pTestCluster
	)		const

privatevirtual

Determine which of two clusters is extremal.

Parameters

isForward	whether propagation direction is forward
pCurrentCluster	current extremal cluster
pTestCluster	potential extremal cluster

Returns: boolean

Implements lar_content::ClusterAssociationAlgorithm.

Definition at line 515 of file TransverseAssociationAlgorithm.cc.

 {
     float currentMinX(0.f), currentMaxX(0.f);
     this->GetExtremalCoordinatesX(pCurrentCluster, currentMinX, currentMaxX);
 
     float testMinX(0.f), testMaxX(0.f);
     this->GetExtremalCoordinatesX(pTestCluster, testMinX, testMaxX);
 
     if (isForward)
     {
         if (std::fabs(testMaxX - currentMaxX) > std::numeric_limits<float>::epsilon())
             return (testMaxX > currentMaxX);
     }
     else
     {
         if (std::fabs(testMinX - currentMaxX) > std::numeric_limits<float>::epsilon())
             return (testMinX < currentMinX);
     }
 
     return LArClusterHelper::SortByNHits(pTestCluster, pCurrentCluster);
 }

bool lar_content::TransverseAssociationAlgorithm::IsOverlapping	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2
	)		const

private

Determine whether two clusters are overlapping.

Parameters

pCluster1	the first cluster
pCluster2	the second cluster

Returns: boolean

Definition at line 445 of file TransverseAssociationAlgorithm.cc.

 {
     CartesianVector innerInner(0.f, 0.f, 0.f), innerOuter(0.f, 0.f, 0.f);
     CartesianVector outerInner(0.f, 0.f, 0.f), outerOuter(0.f, 0.f, 0.f);
     this->GetExtremalCoordinatesX(pInnerCluster, innerInner, innerOuter);
     this->GetExtremalCoordinatesX(pOuterCluster, outerInner, outerOuter);
 
     const CartesianVector innerProjection(LArClusterHelper::GetClosestPosition(outerInner, pInnerCluster));
     const CartesianVector outerProjection(LArClusterHelper::GetClosestPosition(innerOuter, pOuterCluster));
 
     const float innerOverlapSquared((innerProjection - innerOuter).GetMagnitudeSquared());
     const float outerOverlapSquared((outerProjection - outerInner).GetMagnitudeSquared());
 
     return (std::max(innerOverlapSquared, outerOverlapSquared) > m_maxProjectedOverlap * m_maxProjectedOverlap);
 }

bool lar_content::TransverseAssociationAlgorithm::IsTransverseAssociated	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		const ClusterToClustersMap &	nearbyClusters
	)		const

private

Determine whether two clusters are within the same cluster window.

Parameters

pCluster1	the first cluster
pCluster2	the second cluster
nearbyClusters	the nearby cluster map, extracted via use of a kd-tree

Returns: boolean

bool lar_content::TransverseAssociationAlgorithm::IsTransverseAssociated	(	const LArTransverseCluster *const	pTransverseCluster1,
		const LArTransverseCluster *const	pTransverseCluster2,
		const ClusterToClustersMap &	nearbyClusters
	)		const

private

Determine whether two transverse clusters are associated.

Parameters

pTransverseCluster1	the first transverse cluster
pTransverseCluster2	the second transverse cluster
nearbyClusters	the nearby cluster map, extracted via use of a kd-tree

Returns: boolean

Definition at line 404 of file TransverseAssociationAlgorithm.cc.

 {
     if (pInnerTransverseCluster->GetDirection().GetDotProduct(pOuterTransverseCluster->GetDirection()) < m_transverseClusterMinCosTheta)
         return false;
 
     if (!this->IsTransverseAssociated(pInnerTransverseCluster, pOuterTransverseCluster->GetInnerVertex()))
         return false;
 
     if (!this->IsTransverseAssociated(pOuterTransverseCluster, pInnerTransverseCluster->GetOuterVertex()))
         return false;
 
     if (!this->IsTransverseAssociated(pInnerTransverseCluster->GetSeedCluster(), pOuterTransverseCluster->GetSeedCluster(), nearbyClusters))
         return false;
 
     if (this->IsOverlapping(pInnerTransverseCluster->GetSeedCluster(), pOuterTransverseCluster->GetSeedCluster()))
         return false;
 
     return true;
 }

bool lar_content::TransverseAssociationAlgorithm::IsTransverseAssociated	(	const LArTransverseCluster *const	pTransverseCluster,
		const pandora::CartesianVector &	testPosition
	)		const

private

Determine whether one transverse cluster is associated with the vertex from a second transverse cluster.

Parameters

pTransverseCluster	the target cluster
theVertex	the vertex position

Returns: boolean

void lar_content::TransverseAssociationAlgorithm::PopulateClusterAssociationMap	(	const pandora::ClusterVector &	clusterVector,
		ClusterAssociationMap &	clusterAssociationMap
	)		const

privatevirtual

Populate the cluster association map.

Parameters

clusterVector	the cluster vector
clusterAssociationMap	to receive the populated cluster association map

Implements lar_content::ClusterAssociationAlgorithm.

Definition at line 51 of file TransverseAssociationAlgorithm.cc.

 {
     TransverseClusterList transverseClusterList;
 
     try
     {
         ClusterToClustersMap nearbyClusters;
         this->GetNearbyClusterMap(allClusters, nearbyClusters);
 
         if (nearbyClusters.empty())
             return;
 
         // Step 1: Sort the input clusters into sub-samples
         //         (a) shortClusters:  below first length cut
         //         (b) mediumClusters: between first and second length cuts (separated into transverse and longitudinal)
         //         (c) longClusters:   above second length cut
         ClusterVector shortClusters, transverseMediumClusters, longitudinalMediumClusters, longClusters;
         this->SortInputClusters(allClusters, shortClusters, transverseMediumClusters, longitudinalMediumClusters, longClusters);
 
         ClusterVector transverseClusters(shortClusters.begin(), shortClusters.end());
         transverseClusters.insert(transverseClusters.end(), transverseMediumClusters.begin(), transverseMediumClusters.end());
 
         ClusterVector establishedClusters(transverseMediumClusters.begin(), transverseMediumClusters.end());
         establishedClusters.insert(establishedClusters.end(), longitudinalMediumClusters.begin(), longitudinalMediumClusters.end());
         establishedClusters.insert(establishedClusters.end(), longClusters.begin(), longClusters.end());
 
         // Step 2: Form loose transverse associations between short clusters,
         //         without hopping over any established clusters
         ClusterAssociationMap firstAssociationMap;
         this->FillReducedAssociationMap(nearbyClusters, shortClusters, establishedClusters, firstAssociationMap);
 
         // Step 3: Form transverse cluster objects. Basically, try to assign a direction to each
         //         of the clusters in the 'transverseClusters' list. For the short clusters in
         //         this list, the direction is obtained from a straight line fit to its associated
         //         clusters as selected in the previous step.
         this->FillTransverseClusterList(nearbyClusters, transverseClusters, firstAssociationMap, transverseClusterList);
 
         // Step 4: Form loose transverse associations between transverse clusters
         //         (First, associate medium clusters, without hopping over long clusters
         //          Next, associate all transverse clusters, without hopping over any clusters)
         ClusterAssociationMap secondAssociationMap;
         this->FillReducedAssociationMap(nearbyClusters, transverseMediumClusters, longClusters, secondAssociationMap);
         this->FillReducedAssociationMap(nearbyClusters, transverseClusters, allClusters, secondAssociationMap);
 
         // Step 5: Form associations between transverse cluster objects
         //         (These transverse associations must already exist as loose associations
         //          between transverse clusters as identified in the previous step).
         ClusterAssociationMap transverseAssociationMap;
         this->FillTransverseAssociationMap(nearbyClusters, transverseClusterList, secondAssociationMap, transverseAssociationMap);
 
         // Step 6: Finalise the forward/backward transverse associations by symmetrising the
         //         transverse association map and removing any double-counting
         this->FinalizeClusterAssociationMap(transverseAssociationMap, clusterAssociationMap);
     }
     catch (StatusCodeException &statusCodeException)
     {
         std::cout << "TransverseAssociationAlgorithm: exception " << statusCodeException.ToString() << std::endl;
     }
 
     for (TransverseClusterList::const_iterator iter = transverseClusterList.begin(), iterEnd = transverseClusterList.end(); iter != iterEnd; ++iter)
     {
         delete *iter;
     }
 }

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

privatevirtual

Reimplemented from lar_content::ClusterAssociationAlgorithm.

Definition at line 851 of file TransverseAssociationAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FirstLengthCut", m_firstLengthCut));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SecondLengthCut", m_secondLengthCut));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ClusterWindow", m_clusterWindow));
 
     const StatusCode angleStatusCode(XmlHelper::ReadValue(xmlHandle, "clusterAngle", m_clusterAngle));
 
     if (STATUS_CODE_SUCCESS == angleStatusCode)
     {
         m_clusterCosAngle = std::cos(m_clusterAngle * M_PI / 180.f);
         m_clusterTanAngle = std::tan(m_clusterAngle * M_PI / 180.f);
     }
     else if (STATUS_CODE_NOT_FOUND != angleStatusCode)
     {
         return angleStatusCode;
     }
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxTransverseOverlap", m_maxTransverseOverlap));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxProjectedOverlap", m_maxProjectedOverlap));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxLongitudinalOverlap", m_maxLongitudinalOverlap));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "TransverseClusterMinCosTheta", m_transverseClusterMinCosTheta));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "TransverseClusterMinLength", m_transverseClusterMinLength));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "TransverseClusterMaxDisplacement", m_transverseClusterMaxDisplacement));
 
     return ClusterAssociationAlgorithm::ReadSettings(xmlHandle);
 }

void lar_content::TransverseAssociationAlgorithm::SortInputClusters	(	const pandora::ClusterVector &	inputClusters,
		pandora::ClusterVector &	shortClusters,
		pandora::ClusterVector &	transverseMediumClusters,
		pandora::ClusterVector &	longitudinalMediumClusters,
		pandora::ClusterVector &	longClusters
	)		const

private

Separate input clusters by length.

Parameters

inputClusters	the input vector of clusters
shortClusters	the output vector of short clusters
transverseMediumClusters	the output vector of transverse medium clusters
longitudinalMediumClusters	the output vector of longitudinal medium clusters
longClusters	the output vector of all long clusters

Definition at line 159 of file TransverseAssociationAlgorithm.cc.

 {
     for (ClusterVector::const_iterator iter = inputVector.begin(), iterEnd = inputVector.end(); iter != iterEnd; ++iter)
     {
         const Cluster *const pCluster = *iter;
 
         const float clusterLengthT(this->GetTransverseSpan(pCluster));
         const float clusterLengthL(this->GetLongitudinalSpan(pCluster));
         const float clusterLengthSquared(clusterLengthT * clusterLengthT + clusterLengthL * clusterLengthL);
 
         if (clusterLengthSquared < m_firstLengthCut * m_firstLengthCut)
         {
             shortVector.push_back(pCluster);
         }
         else if (clusterLengthSquared < m_secondLengthCut * m_secondLengthCut)
         {
             if (clusterLengthL < clusterLengthT * std::fabs(m_clusterTanAngle))
                 transverseMediumVector.push_back(pCluster);
             else
                 longitudinalMediumVector.push_back(pCluster);
         }
         else
         {
             longVector.push_back(pCluster);
         }
     }
 
     std::sort(shortVector.begin(), shortVector.end(), LArClusterHelper::SortByNHits);
     std::sort(transverseMediumVector.begin(), transverseMediumVector.end(), LArClusterHelper::SortByNHits);
     std::sort(longitudinalMediumVector.begin(), longitudinalMediumVector.end(), LArClusterHelper::SortByNHits);
     std::sort(longVector.begin(), longVector.end(), LArClusterHelper::SortByNHits);
 }