HitWidthClusterMergingAlgorithm class. More...

#include <HitWidthClusterMergingAlgorithm.h>

Inheritance diagram for lar_content::HitWidthClusterMergingAlgorithm:

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

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

Private Member Functions
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...

bool	AreClustersAssociated (const LArHitWidthHelper::ClusterParameters &currentClusterParameters, const LArHitWidthHelper::ClusterParameters &testClusterParameters) const
	Determine whether two clusters are associated. More...

void	FindClosestPointToPosition (const pandora::CartesianVector &position, const LArHitWidthHelper::ConstituentHitVector &constituentHitVector, pandora::CartesianVector &closestPoint) const
	Determine the position of the constituent hit that lies closest to a specified position. More...

void	GetClusterDirection (const LArHitWidthHelper::ConstituentHitVector &constituentHitVector, pandora::CartesianVector &direction, const pandora::CartesianVector &fitReferencePoint, const float fittingWeight) const
	Determine the cluster direction at a reference point by performing a weighted least squared fit to the input consitutent hit positions The fit is performed in a rotated cartesian coordinate system defined by a fitting axis determined by eigen The function is composed of two main loops that calculate the: More...

void	GetConstituentHitSubsetVector (const LArHitWidthHelper::ConstituentHitVector &constituentHitVector, const pandora::CartesianVector &fitReferencePoint, const float fittingWeight, LArHitWidthHelper::ConstituentHitVector &constituentHitSubsetVector) const
	Obtain a vector of the minimum number of hits closest to a reference point that exceed a given weight. More...

void	GetFittingAxes (const LArHitWidthHelper::ConstituentHitVector &constituentHitSubsetVector, pandora::CartesianVector &axisDirection, pandora::CartesianVector &orthoDirection) const
	Obtain the axes of the fitting frame. More...

void	GetFittingCoordinates (const pandora::CartesianVector &axisDirection, const pandora::CartesianVector &constituentHitPosition, float &rL, float &rT) const
	Translate from (x, y, z) coordinates to (rL, rT) coordinates. More...

void	GetGlobalDirection (const pandora::CartesianVector &axisDirection, const float gradient, pandora::CartesianVector &globalDirection) const
	Translate a gradient in the fitting coordinate frame to a direction vector in the detector frame. More...

void	RemoveShortcutAssociations (const pandora::ClusterVector &clusterVector, ClusterAssociationMap &clusterAssociationMap) const
	Remove 'shortcut' associations from the cluster association map. More...

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

Private Attributes
float	m_maxConstituentHitWidth
	The maximum hit width of a constituent hit of broken up hit, units cm. More...

float	m_hitWidthScalingFactor
	The scaling factor of the hit widths. More...

float	m_fittingWeight
	The maximum hit weight considered in the least squared fit. More...

float	m_minClusterWeight
	The threshold hit weight of the original, unscaled cluster to be considered in the merging process. More...

float	m_maxXMergeDistance
	The maximum x distance between merging points of associated clusters, units cm. More...

float	m_maxZMergeDistance
	The maximum z distance between merging points of associated clusters, units cm. More...

float	m_minMergeCosOpeningAngle
	The minimum cosine opening angle of the directions of associated clusters. More...

float	m_minDirectionDeviationCosAngle
	The minimum cosine opening angle of the direction of and associated cluster before and after merge. More...

float	m_minClusterSparseness
	The threshold sparseness of a cluster to be considered in the merging process. More...

LArHitWidthHelper::ClusterToParametersMap	m_clusterToParametersMap
	The map [cluster -> cluster parameters]. 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

HitWidthClusterMergingAlgorithm class.

Definition at line 23 of file HitWidthClusterMergingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::HitWidthClusterMergingAlgorithm::HitWidthClusterMergingAlgorithm ( )

Default constructor.

Definition at line 21 of file HitWidthClusterMergingAlgorithm.cc.

                                                                  :
     m_maxConstituentHitWidth(0.5f),
     m_hitWidthScalingFactor(1.f),
     m_fittingWeight(20.f),
     m_minClusterWeight(0.5f),
     m_maxXMergeDistance(5.f),
     m_maxZMergeDistance(2.f),
     m_minMergeCosOpeningAngle(0.97f),
     m_minDirectionDeviationCosAngle(0.9f),
     m_minClusterSparseness(0.3f)
 {
 }

Member Function Documentation

bool lar_content::HitWidthClusterMergingAlgorithm::AreClustersAssociated	(	const LArHitWidthHelper::ClusterParameters &	currentClusterParameters,
		const LArHitWidthHelper::ClusterParameters &	testClusterParameters
	)		const

private

Determine whether two clusters are associated.

Parameters

currentClusterParameters	parameters defining the current cluster
testClusterParameters	parameters defining the test cluster

Returns: boolean whether the clusters are associated

Definition at line 129 of file HitWidthClusterMergingAlgorithm.cc.

 {
     // check cluster extrema are not too far away in x
     if (testFitParameters.GetLowerXExtrema().GetX() > (currentFitParameters.GetHigherXExtrema().GetX() + m_maxXMergeDistance))
         return false;
 
     // check cluster extrema are not too far away in z
     if (testFitParameters.GetLowerXExtrema().GetZ() > (currentFitParameters.GetHigherXExtrema().GetZ() + m_maxZMergeDistance) ||
         testFitParameters.GetLowerXExtrema().GetZ() < (currentFitParameters.GetHigherXExtrema().GetZ() - m_maxZMergeDistance))
     {
         return false;
     }
 
     // find appropriate test merging point (may be different to lowerXExtrema when hits overlap)
     CartesianVector testMergePoint(0.f, 0.f, 0.f);
     if (testFitParameters.GetLowerXExtrema().GetX() < currentFitParameters.GetHigherXExtrema().GetX())
     {
         this->FindClosestPointToPosition(currentFitParameters.GetHigherXExtrema(), testFitParameters.GetConstituentHitVector(), testMergePoint);
 
         // check closeness in z is maintained
         if (testMergePoint.GetZ() > (currentFitParameters.GetHigherXExtrema().GetZ() + m_maxZMergeDistance) ||
             testMergePoint.GetZ() < (currentFitParameters.GetHigherXExtrema().GetZ() - m_maxZMergeDistance))
         {
             return false;
         }
     }
     else
     {
         testMergePoint = testFitParameters.GetLowerXExtrema();
     }
 
     CartesianVector currentClusterDirection(0.f, 0.f, 0.f), testClusterDirection(0.f, 0.f, 0.f);
 
     try
     {
         this->GetClusterDirection(currentFitParameters.GetConstituentHitVector(), currentClusterDirection,
             currentFitParameters.GetHigherXExtrema(), m_fittingWeight);
         this->GetClusterDirection(testFitParameters.GetConstituentHitVector(), testClusterDirection, testMergePoint, m_fittingWeight);
     }
     catch (const StatusCodeException &)
     {
         return false;
     }
 
     // check clusters have a similar direction
     if (currentClusterDirection.GetCosOpeningAngle(testClusterDirection) < m_minMergeCosOpeningAngle)
         return false;
 
     // check that the new direction is consistent with the old clusters
     LArHitWidthHelper::ConstituentHitVector newConstituentHitVector(currentFitParameters.GetConstituentHitVector());
     newConstituentHitVector.insert(newConstituentHitVector.end(), testFitParameters.GetConstituentHitVector().begin(),
         testFitParameters.GetConstituentHitVector().end());
 
     const CartesianVector midpoint((currentFitParameters.GetHigherXExtrema() + testMergePoint) * 0.5);
     CartesianVector newClusterDirection(0.f, 0.f, 0.f);
 
     try
     {
         this->GetClusterDirection(newConstituentHitVector, newClusterDirection, midpoint, m_fittingWeight);
     }
     catch (const StatusCodeException &)
     {
         return false;
     }
 
     if (newClusterDirection.GetCosOpeningAngle(currentClusterDirection) < m_minDirectionDeviationCosAngle ||
         newClusterDirection.GetCosOpeningAngle(testClusterDirection) < m_minDirectionDeviationCosAngle)
     {
         return false;
     }
 
     return true;
 }

void lar_content::HitWidthClusterMergingAlgorithm::FindClosestPointToPosition	(	const pandora::CartesianVector &	position,
		const LArHitWidthHelper::ConstituentHitVector &	constituentHitVector,
		pandora::CartesianVector &	closestPoint
	)		const

private

Determine the position of the constituent hit that lies closest to a specified position.

Parameters

position	the point to which the consituent hits will be compared
constituentHitVector	the input vector of constituent hits
closestPoint	the position of the closest constituent hit

Definition at line 206 of file HitWidthClusterMergingAlgorithm.cc.

 {
     float minDistanceSquared(std::numeric_limits<float>::max());
     for (const LArHitWidthHelper::ConstituentHit &constituentHit : constituentHitVector)
     {
         const CartesianVector &hitPosition(constituentHit.GetPositionVector());
         const float separationDistanceSquared(hitPosition.GetDistanceSquared(position));
 
         if (separationDistanceSquared < minDistanceSquared)
         {
             minDistanceSquared = separationDistanceSquared;
             closestPoint = hitPosition;
         }
     }
 }

void lar_content::HitWidthClusterMergingAlgorithm::GetClusterDirection	(	const LArHitWidthHelper::ConstituentHitVector &	constituentHitVector,
		pandora::CartesianVector &	direction,
		const pandora::CartesianVector &	fitReferencePoint,
		const float	fittingWeight
	)		const

private

Determine the cluster direction at a reference point by performing a weighted least squared fit to the input consitutent hit positions The fit is performed in a rotated cartesian coordinate system defined by a fitting axis determined by eigen The function is composed of two main loops that calculate the:

    1. rL & rT weighted means
    2. gradient of the fit
    The fit is performed using a subset of points that are closest to the fitReferencePoint

Parameters

constituentHitVector	the input vector of constituent hits
direction	the fitted cluster direction
fitReferencePoint	the hits closest to this point are included in the fit
fittingWeight	the weight that is considered in the fit

Definition at line 225 of file HitWidthClusterMergingAlgorithm.cc.

 {
     float weightSum(0.f), weightedLSum(0.f), weightedTSum(0.f);
     bool isLConstant(true), isTConstant(true);
 
     // get fitting subset vector
     LArHitWidthHelper::ConstituentHitVector constituentHitSubsetVector;
     this->GetConstituentHitSubsetVector(constituentHitVector, fitReferencePoint, fittingWeight, constituentHitSubsetVector);
 
     // determine the fitting axes
     CartesianVector axisDirection(0.f, 0.f, 0.f), orthoDirection(0.f, 0.f, 0.f);
     this->GetFittingAxes(constituentHitSubsetVector, axisDirection, orthoDirection);
 
     // the comparison to check if constituent hit positions are constant in rL or rT (would lead to a division by zero)
     float firstHitL(0.f), firstHitT(0.f);
     this->GetFittingCoordinates(axisDirection, constituentHitSubsetVector.begin()->GetPositionVector(), firstHitL, firstHitT);
 
     for (const LArHitWidthHelper::ConstituentHit &constituentHit : constituentHitSubsetVector)
     {
         const float hitWeight(constituentHit.GetHitWidth());
         float rL(0.f), rT(0.f);
         this->GetFittingCoordinates(axisDirection, constituentHit.GetPositionVector(), rL, rT);
 
         if (std::fabs(firstHitL - rL) > std::numeric_limits<float>::epsilon())
             isLConstant = false;
 
         if (std::fabs(firstHitT - rT) > std::numeric_limits<float>::epsilon())
             isTConstant = false;
 
         weightedLSum += rL * hitWeight;
         weightedTSum += rT * hitWeight;
         weightSum += hitWeight;
     }
 
     if (weightSum < std::numeric_limits<float>::epsilon())
     {
         std::cout << "HitWidthClusterMergingAlgorithm::GetWeightedGradient - hit weight in fit is negative or equivalent to zero" << std::endl;
         throw StatusCodeException(STATUS_CODE_NOT_ALLOWED);
     }
 
     // return ortho direction for a cluster with constant rL
     if (isLConstant)
     {
         // ATTN direction convention is to point in direction of increasing x
         direction = (orthoDirection.GetX() < 0.f) ? orthoDirection * (-1.f) : orthoDirection;
         return;
     }
 
     // return axis direction for a cluster with constant rT
     if (isTConstant)
     {
         // ATTN direction convention is to point in direction of increasing x
         direction = (axisDirection.GetX() < 0.f) ? axisDirection * (-1.f) : axisDirection;
         return;
     }
 
     const float weightedLMean(weightedLSum / weightSum), weightedTMean(weightedTSum / weightSum);
     float numerator(0.f), denominator(0.f);
 
     for (const LArHitWidthHelper::ConstituentHit &constituentHit : constituentHitSubsetVector)
     {
         const float hitWeight(constituentHit.GetHitWidth());
         float rL(0.f), rT(0.f);
         this->GetFittingCoordinates(axisDirection, constituentHit.GetPositionVector(), rL, rT);
 
         numerator += hitWeight * (rL - weightedLMean) * (rT - weightedTMean);
         denominator += hitWeight * pow(rL - weightedLMean, 2);
     }
 
     const float gradient(numerator / denominator);
 
     // change coordinates to z=mx+c fit and normalise
     this->GetGlobalDirection(axisDirection, gradient, direction);
 
     // ATTN direction convention is to point in direction of increasing x
     if (direction.GetX() < 0.f)
         direction *= -1.f;
 }

void lar_content::HitWidthClusterMergingAlgorithm::GetConstituentHitSubsetVector	(	const LArHitWidthHelper::ConstituentHitVector &	constituentHitVector,
		const pandora::CartesianVector &	fitReferencePoint,
		const float	fittingWeight,
		LArHitWidthHelper::ConstituentHitVector &	constituentHitSubsetVector
	)		const

private

Obtain a vector of the minimum number of hits closest to a reference point that exceed a given weight.

Parameters

constituentHitVector	the input vector of constituent hits
fitReferencePoint	the reference point
fittingWeight	the specified cumulative hit weight
constituentHitSubsetVector	the subset of constituent hits

Definition at line 307 of file HitWidthClusterMergingAlgorithm.cc.

 {
     LArHitWidthHelper::ConstituentHitVector sortedConstituentHitVector(constituentHitVector);
 
     // sort hits with respect to their distance to the fitReferencePoint (closest -> furthest)
     std::sort(sortedConstituentHitVector.begin(), sortedConstituentHitVector.end(),
         LArHitWidthHelper::ConstituentHit::SortByDistanceToPoint(fitReferencePoint));
 
     float weightCount(0.f);
     for (const LArHitWidthHelper::ConstituentHit &constituentHit : sortedConstituentHitVector)
     {
         constituentHitSubsetVector.push_back(constituentHit);
 
         weightCount += constituentHit.GetHitWidth();
 
         if (weightCount > fittingWeight)
             break;
     }
 }

void lar_content::HitWidthClusterMergingAlgorithm::GetFittingAxes	(	const LArHitWidthHelper::ConstituentHitVector &	constituentHitSubsetVector,
		pandora::CartesianVector &	axisDirection,
		pandora::CartesianVector &	orthoDirection
	)		const

private

Obtain the axes of the fitting frame.

Parameters

constituentHitSubsetVector	the input vector of constituent hits
axisDirection	the fitting 'x-axis'
orthoDirection	the fitting 'z-axis'

Definition at line 330 of file HitWidthClusterMergingAlgorithm.cc.

 {
     CartesianPointVector constituentHitSubsetPositionVector(LArHitWidthHelper::GetConstituentHitPositionVector(constituentHitSubsetVector));
 
     if (constituentHitSubsetPositionVector.size() < 2)
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     CartesianVector centroid(0.f, 0.f, 0.f);
     LArPcaHelper::EigenVectors eigenVecs;
     LArPcaHelper::EigenValues eigenValues(0.f, 0.f, 0.f);
     LArPcaHelper::RunPca(constituentHitSubsetPositionVector, centroid, eigenValues, eigenVecs);
 
     axisDirection = eigenVecs.at(0);
 
     // ATTN fitting convention is to point in direction of increasing z
     if (axisDirection.GetZ() < 0.f)
         axisDirection *= -1.f;
 
     // Use y-axis to generate an orthogonal axis (assuming that cluster occupies x-z plane)
     const CartesianVector yAxis(0.f, 1.f, 0.f);
     orthoDirection = yAxis.GetCrossProduct(axisDirection).GetUnitVector();
 }

void lar_content::HitWidthClusterMergingAlgorithm::GetFittingCoordinates	(	const pandora::CartesianVector &	axisDirection,
		const pandora::CartesianVector &	constituentHitPosition,
		float &	rL,
		float &	rT
	)		const

private

Translate from (x, y, z) coordinates to (rL, rT) coordinates.

Parameters

axisDirection	the fitting 'x-axis'
constituentHitPosition	the (x, y, z) position of a constituent hit
rL	the fitting 'x' coordinate
rT	the fitting 'z' coordinate

Definition at line 356 of file HitWidthClusterMergingAlgorithm.cc.

 {
     // axisDirection is in positive z by convention so use opening angle to obtain coordinates in rotated frame
     const CartesianVector xAxis(1.f, 0.f, 0.f);
     const float openingAngle(axisDirection.GetOpeningAngle(xAxis)), c(std::cos(openingAngle)), s(std::sin(openingAngle));
 
     rL = (c * constituentHitPosition.GetX()) + (s * constituentHitPosition.GetZ());
     rT = (c * constituentHitPosition.GetZ()) - (s * constituentHitPosition.GetX());
 }

void lar_content::HitWidthClusterMergingAlgorithm::GetGlobalDirection	(	const pandora::CartesianVector &	axisDirection,
		const float	gradient,
		pandora::CartesianVector &	globalDirection
	)		const

private

Translate a gradient in the fitting coordinate frame to a direction vector in the detector frame.

Parameters

axisDirection	the fitting 'x-axis'
gradient	the gradient dT/dL
globalDirection	the direction vector in the detector frame

Definition at line 369 of file HitWidthClusterMergingAlgorithm.cc.

 {
     const CartesianVector xAxis(1.f, 0.f, 0.f);
     const float openingAngle(axisDirection.GetOpeningAngle(xAxis)), c(std::cos(openingAngle)), s(std::sin(openingAngle));
     const float deltaL(1.f), deltaT(gradient);
 
     const float x = (c * deltaL) - (s * deltaT);
     const float z = (c * deltaT) + (s * deltaL);
 
     globalDirection.SetValues(x, 0.f, z);
     globalDirection = globalDirection.GetUnitVector();
 }

void lar_content::HitWidthClusterMergingAlgorithm::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 36 of file HitWidthClusterMergingAlgorithm.cc.

 {
     // clear map if already full i.e. from other view clustering
     if (!m_clusterToParametersMap.empty())
         m_clusterToParametersMap.clear();
 
     for (const Cluster *const pCluster : *pClusterList)
     {
         // the original cluster weight, with no hit scaling or hit padding
         if (LArHitWidthHelper::GetOriginalTotalClusterWeight(pCluster) < m_minClusterWeight)
             continue;
 
         const unsigned int numberOfProposedConstituentHits(
             LArHitWidthHelper::GetNProposedConstituentHits(pCluster, m_maxConstituentHitWidth, m_hitWidthScalingFactor));
 
         if (numberOfProposedConstituentHits == 0)
             continue;
 
         // clusterSparseness [0 -> 1] where a higher value indicates sparseness
         const float clusterSparseness(1.f - (static_cast<float>(pCluster->GetNCaloHits()) / static_cast<float>(numberOfProposedConstituentHits)));
 
         if (clusterSparseness < m_minClusterSparseness)
             continue;
 
         m_clusterToParametersMap.insert(std::pair<const Cluster *, LArHitWidthHelper::ClusterParameters>(
             pCluster, LArHitWidthHelper::ClusterParameters(pCluster, m_maxConstituentHitWidth, false, m_hitWidthScalingFactor)));
 
         clusterVector.push_back(pCluster);
     }
 
     std::sort(clusterVector.begin(), clusterVector.end(), LArHitWidthHelper::SortByHigherXExtrema(m_clusterToParametersMap));
 }

bool lar_content::HitWidthClusterMergingAlgorithm::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 102 of file HitWidthClusterMergingAlgorithm.cc.

 {
     //ATTN - cannot use map since higherXExtrema may have changed during merging
     const LArHitWidthHelper::ConstituentHitVector currentConstituentHitVector(
         LArHitWidthHelper::GetConstituentHits(pCurrentCluster, m_maxConstituentHitWidth, m_hitWidthScalingFactor, false));
     const LArHitWidthHelper::ConstituentHitVector testConstituentHitVector(
         LArHitWidthHelper::GetConstituentHits(pTestCluster, m_maxConstituentHitWidth, m_hitWidthScalingFactor, false));
     const CartesianVector currentHigherXExtrema(LArHitWidthHelper::GetExtremalCoordinatesHigherX(currentConstituentHitVector));
     const CartesianVector testHigherXExtrema(LArHitWidthHelper::GetExtremalCoordinatesHigherX(testConstituentHitVector));
     float currentMaxX(currentHigherXExtrema.GetX()), testMaxX(testHigherXExtrema.GetX());
 
     if (isForward)
     {
         if (std::fabs(testMaxX - currentMaxX) > std::numeric_limits<float>::epsilon())
             return (testMaxX > currentMaxX);
     }
     else
     {
         if (std::fabs(testMaxX - currentMaxX) > std::numeric_limits<float>::epsilon())
             return (testMaxX < currentMaxX);
     }
 
     return LArClusterHelper::SortByNHits(pTestCluster, pCurrentCluster);
 }

void lar_content::HitWidthClusterMergingAlgorithm::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 71 of file HitWidthClusterMergingAlgorithm.cc.

 {
     // ATTN this method assumes that clusters have been sorted by extremal x position (low higherXExtrema -> high higherXExtrema)
     for (ClusterVector::const_iterator iterCurrentCluster = clusterVector.begin(); iterCurrentCluster != clusterVector.end(); ++iterCurrentCluster)
     {
         const Cluster *const pCurrentCluster = *iterCurrentCluster;
         const LArHitWidthHelper::ClusterParameters &currentClusterParameters(
             LArHitWidthHelper::GetClusterParameters(pCurrentCluster, m_clusterToParametersMap));
 
         for (ClusterVector::const_iterator iterTestCluster = iterCurrentCluster; iterTestCluster != clusterVector.end(); ++iterTestCluster)
         {
             if (iterCurrentCluster == iterTestCluster)
                 continue;
 
             const Cluster *const pTestCluster = *iterTestCluster;
             const LArHitWidthHelper::ClusterParameters &testClusterParameters(
                 LArHitWidthHelper::GetClusterParameters(pTestCluster, m_clusterToParametersMap));
 
             if (!this->AreClustersAssociated(currentClusterParameters, testClusterParameters))
                 continue;
 
             clusterAssociationMap[pCurrentCluster].m_forwardAssociations.insert(pTestCluster);
             clusterAssociationMap[pTestCluster].m_backwardAssociations.insert(pCurrentCluster);
         }
     }
 
     this->RemoveShortcutAssociations(clusterVector, clusterAssociationMap);
 }

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

privatevirtual

Reimplemented from lar_content::ClusterAssociationAlgorithm.

Definition at line 445 of file HitWidthClusterMergingAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FittingWeight", m_fittingWeight));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterWeight", m_minClusterWeight));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxXMergeDistance", m_maxXMergeDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxZMergeDistance", m_maxZMergeDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinMergeCosOpeningAngle", m_minMergeCosOpeningAngle));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinDirectionDeviationCosAngle", m_minDirectionDeviationCosAngle));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxConstituentHitWidth", m_maxConstituentHitWidth));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "HitWidthScalingFactor", m_hitWidthScalingFactor));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterSparseness", m_minClusterSparseness));
 
     return ClusterAssociationAlgorithm::ReadSettings(xmlHandle);
 }

void lar_content::HitWidthClusterMergingAlgorithm::RemoveShortcutAssociations	(	const pandora::ClusterVector &	clusterVector,
		ClusterAssociationMap &	clusterAssociationMap
	)		const

private

Remove 'shortcut' associations from the cluster association map.

Parameters

clusterVector	the vector of clusters considered in the merging process
clusterAssociationMap	the mapping of clusters to forward/backward associations

Definition at line 384 of file HitWidthClusterMergingAlgorithm.cc.

 {
     // Create temporary map so can delete elements whilst still iterating over them
     ClusterAssociationMap tempMap(clusterAssociationMap);
 
     for (const Cluster *const pCluster : clusterVector)
     {
         const ClusterAssociationMap::const_iterator primaryMapIter = clusterAssociationMap.find(pCluster);
 
         if (primaryMapIter == clusterAssociationMap.end())
             continue;
 
         // put ClusterSet into ClusterVector
         ClusterVector primaryForwardAssociations(
             primaryMapIter->second.m_forwardAssociations.begin(), primaryMapIter->second.m_forwardAssociations.end());
         std::sort(primaryForwardAssociations.begin(), primaryForwardAssociations.end(), LArClusterHelper::SortByNHits);
 
         // remove primary clusters that are present in secondary associations of other primary clusters
         for (const Cluster *const pConsideredCluster : primaryForwardAssociations)
         {
             for (const Cluster *const pPrimaryCluster : primaryForwardAssociations)
             {
                 if (pConsideredCluster == pPrimaryCluster)
                     continue;
 
                 const ClusterAssociationMap::const_iterator secondaryMapIter = clusterAssociationMap.find(pPrimaryCluster);
 
                 // if primary cluster has no associations (this shouldn't ever be the case)
                 if (secondaryMapIter == clusterAssociationMap.end())
                     continue;
 
                 const ClusterSet &secondaryForwardAssociations(secondaryMapIter->second.m_forwardAssociations);
 
                 if (secondaryForwardAssociations.find(pConsideredCluster) != secondaryForwardAssociations.end())
                 {
                     ClusterSet &tempPrimaryForwardAssociations(tempMap.find(pCluster)->second.m_forwardAssociations);
                     const ClusterSet::const_iterator forwardAssociationToRemove(tempPrimaryForwardAssociations.find(pConsideredCluster));
 
                     // if association has already been removed
                     if (forwardAssociationToRemove == tempPrimaryForwardAssociations.end())
                         continue;
 
                     ClusterSet &tempPrimaryBackwardAssociations(tempMap.find(pConsideredCluster)->second.m_backwardAssociations);
                     const ClusterSet::const_iterator backwardAssociationToRemove(tempPrimaryBackwardAssociations.find(pCluster));
 
                     // if association has already been removed
                     if (backwardAssociationToRemove == tempPrimaryBackwardAssociations.end())
                         continue;
 
                     tempPrimaryForwardAssociations.erase(forwardAssociationToRemove);
                     tempPrimaryBackwardAssociations.erase(backwardAssociationToRemove);
                 }
             }
         }
     }
 
     clusterAssociationMap = tempMap;
 }