NViewDeltaRayMatchingAlgorithm class. More...

#include <NViewDeltaRayMatchingAlgorithm.h>

Inheritance diagram for lar_content::NViewDeltaRayMatchingAlgorithm< T >:

Public Types
typedef std::map< const pandora::CaloHit , const pandora::Cluster >	HitToClusterMap

typedef std::map< const pandora::Cluster , const pandora::ParticleFlowObject >	ClusterToPfoMap

typedef std::map< const pandora::Cluster *, pandora::ClusterList >	ClusterProximityMap

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

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

typedef std::vector< HitKDNode2D >	HitKDNode2DList

typedef std::vector < pandora::HitType >	HitTypeVector

Public Types inherited from lar_content::NViewMatchingAlgorithm< T >
typedef T	MatchingType

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

pandora::StatusCode	GetMuonCluster (const pandora::PfoList &commonMuonPfoList, const pandora::HitType hitType, const pandora::Cluster *&pMuonCluster) const
	Return the cluster of the common cosmic ray pfo in a given view (function demands there to be only one common CR pfo) More...

pandora::StatusCode	PerformThreeViewMatching (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, const pandora::Cluster *const pCluster3, float &reducedChiSquared) const
	To determine how well three clusters (one in each view) map onto one another expressing this in terms of a chi-squared like parameter. More...

pandora::StatusCode	PerformThreeViewMatching (const pandora::Cluster const pClusterU, const pandora::Cluster const pClusterV, const pandora::Cluster *const pClusterW, float &chiSquaredSum, unsigned int &nSamplingPoints, unsigned int &nMatchedSamplingPoints, XOverlap &XOverlap) const
	To determine how well three clusters (one in each view) map onto one another expressing this in terms of a chi-squared like parameter. More...

pandora::StatusCode	PerformThreeViewMatching (const pandora::CaloHitList &pCluster1, const pandora::CaloHitList &pCluster2, const pandora::CaloHitList &pCluster3, float &reducedChiSquared) const
	To determine how well three CaloHitLists (one in each view) map onto one another expressing this in terms of a chi-squared like parameter. More...

pandora::StatusCode	PerformThreeViewMatching (const pandora::CaloHitList &clusterU, const pandora::CaloHitList &clusterV, const pandora::CaloHitList &clusterW, float &chiSquaredSum, unsigned int &nSamplingPoints, unsigned int &nMatchedSamplingPoints, XOverlap &XOverlap) const
	To determine how well three CaloHitLists (one for each view) map onto one another expressing this in terms of a chi-squared like parameter. More...

pandora::StatusCode	ProjectMuonPositions (const pandora::HitType &thirdViewHitType, const pandora::ParticleFlowObject *const pParentMuon, pandora::CartesianPointVector &projectedPositions) const
	Use two views of a cosmic ray pfo to calculate projected positions in a given the third view. More...

pandora::StatusCode	GetProjectedPositions (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, pandora::CartesianPointVector &projectedPositions) const
	Use two clusters from different views to calculate projected positions in the remaining third view. More...

pandora::StatusCode	CollectHitsFromMuon (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, const pandora::Cluster const pThirdViewCluster, const pandora::ParticleFlowObject const pParentMuon, const float minDistanceFromMuon, const float maxDistanceToCollected, pandora::CaloHitList &collectedHits) const
	In one view, pull out any hits from a cosmic ray cluster that belong to the child delta ray cluster. More...

void	CollectHitsFromMuon (const pandora::CartesianVector &positionOnMuon, const pandora::CartesianVector &muonDirection, const pandora::Cluster *const pMuonCluster, const pandora::CartesianPointVector &deltaRayProjectedPositions, const float &minDistanceFromMuon, const float maxDistanceToCollected, pandora::CaloHitList &collectedHits) const
	In one view, pull out any hits from a cosmic ray cluster that belong to the child delta ray cluster. More...

pandora::StatusCode	ParameteriseMuon (const pandora::ParticleFlowObject const pParentMuon, const pandora::Cluster const pDeltaRayCluster, pandora::CartesianVector &positionOnMuon, pandora::CartesianVector &muonDirection) const
	Parameterise the projection of a cosmic ray track in order to avoid poor/sparse projections. More...

pandora::StatusCode	ParameteriseMuon (const pandora::ParticleFlowObject *const pParentMuon, const pandora::CartesianPointVector &deltaRayProjectedPositions, const pandora::HitType hitType, pandora::CartesianVector &positionOnMuon, pandora::CartesianVector &muonDirection) const
	Parameterise the projection of a cosmic ray track in order to avoid poor/sparse projections. More...

void	SplitMuonCluster (const std::string &clusterListName, const pandora::Cluster const pMuonCluster, const pandora::CaloHitList &collectedHits, const pandora::Cluster &pDeltaRayCluster) const
	Move a list of hits from a cosmic ray cluster into the given child delta ray cluster. More...

bool	CreatePfos (ProtoParticleVector &protoParticleVector)
	Create delta ray pfos maxmising completeness by searching for and merging in any stray clusters. More...

void	UpdateForNewClusters (const pandora::ClusterVector &newClusterVector, const pandora::PfoVector &pfoVector)
	Add a new cluster to algorithm ownership maps and, if it a delta ray cluster, to the underlying matches container (tensor/matrix) More...

void	UpdateUponDeletion (const pandora::Cluster *const pDeletedCluster)
	Update to reflect cluster deletion. More...

void	SelectInputClusters (const pandora::ClusterList *const pInputClusterList, pandora::ClusterList &selectedClusterList) const
	Select a subset of input clusters for processing in this algorithm. More...

void	PrepareInputClusters (pandora::ClusterList &preparedClusterList)
	Perform any preparatory steps required on the input clusters, e.g. caching expensive fit results. More...

Public Member Functions inherited from lar_content::NViewMatchingAlgorithm< T >
	NViewMatchingAlgorithm ()
	Default constructor. More...

virtual	~NViewMatchingAlgorithm ()
	Destructor. More...

void	UpdateForNewCluster (const pandora::Cluster *const pNewCluster)
	Update to reflect addition of a new cluster to the problem space. More...

void	UpdateUponDeletion (const pandora::Cluster *const pDeletedCluster)
	Update to reflect cluster deletion. More...

const std::string &	GetClusterListName (const pandora::HitType hitType) const
	Get the cluster list name corresponding to a specified hit type. More...

const pandora::ClusterList &	GetInputClusterList (const pandora::HitType hitType) const
	Get the input cluster list corresponding to a specified hit type. More...

const pandora::ClusterList &	GetSelectedClusterList (const pandora::HitType hitType) const
	Get the selected cluster list corresponding to a specified hit type. More...

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

virtual	~MatchingBaseAlgorithm ()
	Destructor. More...

virtual void	CalculateOverlapResult (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, const pandora::Cluster *const pCluster3=nullptr)=0
	Calculate cluster overlap result and store in container. More...

virtual bool	MakeClusterMerges (const ClusterMergeMap &clusterMergeMap)
	Merge clusters together. More...

virtual bool	CreateThreeDParticles (const ProtoParticleVector &protoParticleVector)
	Create particles using findings from recent algorithm processing. More...

virtual void	SetPfoParameters (const ProtoParticle &protoParticle, PandoraContentApi::ParticleFlowObject::Parameters &pfoParameters) const
	Set Pfo properties. More...

virtual void	SetPfoParticleId (PandoraContentApi::ParticleFlowObject::Parameters &pfoParameters) const
	Set pfo particle id. More...

Protected Member Functions
virtual bool	DoesClusterPassTensorThreshold (const pandora::Cluster *const pCluster) const =0
	To check whether a given cluster meets the requirements to be added into the matching container (tensor/matrix) More...

void	FillStrayClusterList (const pandora::HitType hitType)
	Fill the stray cluster list with clusters that do not pass the tensor threshold requirement. More...

void	GetNearbyMuonPfos (const pandora::Cluster *const pCluster, pandora::ClusterList &consideredClusters, pandora::PfoList &nearbyMuonPfos) const
	Use the cluster proximity map to travel along paths of nearby clusters finding the cosmic ray clusters on which they terminate. More...

void	GetClusterSpanX (const pandora::CaloHitList &caloHitList, float &xMin, float &xMax) const
	Calculate the xSpan of a list of CaloHits. More...

pandora::StatusCode	GetClusterSpanZ (const pandora::CaloHitList &caloHitList, const float xMin, const float xMax, float &zMin, float &zMax) const
	Calculate the zSpan of a list of CaloHits in a specified x range. More...

void	CollectStrayClusters (const pandora::Cluster *const pClusterToEnlarge, const float rangeMinX, const float rangeMaxX, pandora::ClusterList &collectedClusters)
	Collect the stray clusters that are close to a specified cluster and that lie within a given x range. More...

void	AddInStrayClusters (const pandora::Cluster *const pClusterToEnlarge, const pandora::ClusterList &collectedClusters)
	Merge in the collected stray clusters of a given delta ray cluster. More...

void	TidyUp ()
	Tidy member variables in derived class. More...

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

Protected Member Functions inherited from lar_content::NViewMatchingAlgorithm< T >
MatchingType &	GetMatchingControl ()
	Get the matching control. More...

virtual void	SelectAllInputClusters ()
	Select a subset of input clusters for processing in this algorithm. More...

virtual void	PrepareAllInputClusters ()
	Perform any preparatory steps required, e.g. caching expensive fit results for clusters. More...

virtual void	PerformMainLoop ()
	Main loop over cluster combinations in order to populate the overlap container. Responsible for calling CalculateOverlapResult. More...

Protected Member Functions inherited from lar_content::MatchingBaseAlgorithm
virtual void	ExamineOverlapContainer ()=0
	Examine contents of overlap container, collect together best-matching 2D particles and modify clusters as required. More...

Protected Attributes
std::string	m_muonPfoListName
	The list of reconstructed cosmic ray pfos. More...

pandora::ClusterList	m_strayClusterListU
	The list of U clusters that do not pass the tensor threshold requirement. More...

pandora::ClusterList	m_strayClusterListV
	The list of V clusters that do not pass the tensor threshold requirement. More...

pandora::ClusterList	m_strayClusterListW
	The list of W clusters that do not pass the tensor threshold requirement. More...

DeltaRayMatchingContainers	m_deltaRayMatchingContainers
	The class of hit, cluster and pfo ownership and proximity maps. More...

float	m_pseudoChi2Cut
	Pseudo chi2 cut for three view matching. More...

float	m_xOverlapWindow
	The maximum allowed displacement in x position. More...

float	m_minMatchedFraction
	The threshold matched fraction of sampling points for a good match. More...

unsigned int	m_minMatchedPoints
	The threshold number of matched sampling points for a good match. More...

unsigned int	m_minProjectedPositions
	The threshold number of projected points for a good projection. More...

float	m_maxCosmicRayHitFraction
	The maximum allowed fraction of hits to be removed from the cosmic ray track. More...

float	m_maxDistanceToCluster
	the maximum distance of a projected point to the cosmic ray cluster used when parameterising the cosmic ray cluster More...

float	m_maxDistanceToReferencePoint
	the maximum distance of a projected point to the cosmic ray vertex used when parameterising the cosmic ray cluster More...

float	m_strayClusterSeparation
	The maximum allowed separation of a stray cluster and a delta ray cluster for merge. More...

Protected Attributes inherited from lar_content::NViewMatchingAlgorithm< T >
MatchingType	m_matchingControl
	The matching control. More...

Detailed Description

template<typename T>
class lar_content::NViewDeltaRayMatchingAlgorithm< T >

NViewDeltaRayMatchingAlgorithm class.

Definition at line 23 of file NViewDeltaRayMatchingAlgorithm.h.

Member Typedef Documentation

template<typename T>

typedef std::map<const pandora::Cluster *, pandora::ClusterList> lar_content::NViewDeltaRayMatchingAlgorithm< T >::ClusterProximityMap

Definition at line 28 of file NViewDeltaRayMatchingAlgorithm.h.

template<typename T>

typedef std::map<const pandora::Cluster *, const pandora::ParticleFlowObject *> lar_content::NViewDeltaRayMatchingAlgorithm< T >::ClusterToPfoMap

Definition at line 27 of file NViewDeltaRayMatchingAlgorithm.h.

template<typename T>

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

Definition at line 31 of file NViewDeltaRayMatchingAlgorithm.h.

template<typename T>

typedef std::vector<HitKDNode2D> lar_content::NViewDeltaRayMatchingAlgorithm< T >::HitKDNode2DList

Definition at line 32 of file NViewDeltaRayMatchingAlgorithm.h.

template<typename T>

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

Definition at line 30 of file NViewDeltaRayMatchingAlgorithm.h.

template<typename T>

typedef std::map<const pandora::CaloHit *, const pandora::Cluster *> lar_content::NViewDeltaRayMatchingAlgorithm< T >::HitToClusterMap

Definition at line 26 of file NViewDeltaRayMatchingAlgorithm.h.

template<typename T>

typedef std::vector<pandora::HitType> lar_content::NViewDeltaRayMatchingAlgorithm< T >::HitTypeVector

Definition at line 34 of file NViewDeltaRayMatchingAlgorithm.h.

Constructor & Destructor Documentation

template<typename T >

lar_content::NViewDeltaRayMatchingAlgorithm< T >::NViewDeltaRayMatchingAlgorithm ( )

Default constructor.

Definition at line 33 of file NViewDeltaRayMatchingAlgorithm.cc.

                                                                   :
     m_pseudoChi2Cut(1.5f),
     m_xOverlapWindow(1.f),
     m_minMatchedFraction(0.5),
     m_minMatchedPoints(3),
     m_minProjectedPositions(3),
     m_maxCosmicRayHitFraction(0.05f),
     m_maxDistanceToCluster(0.5f),
     m_maxDistanceToReferencePoint(5.f),
     m_strayClusterSeparation(2.f)
 {
 }

Member Function Documentation

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::AddInStrayClusters	(	const pandora::Cluster *const	pClusterToEnlarge,
		const pandora::ClusterList &	collectedClusters
	)

protected

Merge in the collected stray clusters of a given delta ray cluster.

Parameters

pClusterToEnlarge	the delta ray cluster to enlarge
collectedClusters	the list of collected stray clusters

Definition at line 813 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     this->UpdateUponDeletion(pClusterToEnlarge);
 
     for (const Cluster *const pCollectedCluster : collectedClusters)
     {
         this->UpdateUponDeletion(pCollectedCluster);
 
         std::string clusterListName(this->GetClusterListName(LArClusterHelper::GetClusterHitType(pClusterToEnlarge)));
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
             PandoraContentApi::MergeAndDeleteClusters(*this, pClusterToEnlarge, pCollectedCluster, clusterListName, clusterListName));
     }
 
     m_deltaRayMatchingContainers.AddClustersToContainers({pClusterToEnlarge}, {nullptr});
 }

template<typename T>

pandora::StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::CollectHitsFromMuon	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		const pandora::Cluster *const	pThirdViewCluster,
		const pandora::ParticleFlowObject *const	pParentMuon,
		const float	minDistanceFromMuon,
		const float	maxDistanceToCollected,
		pandora::CaloHitList &	collectedHits
	)		const

In one view, pull out any hits from a cosmic ray cluster that belong to the child delta ray cluster.

Parameters

pCluster1	the address of a delta ray cluster in a view that is to go unmodified
pCluster2	the address of a delta ray cluster in the other view that is to unmodified
pThirdViewCluster	the address of the delta ray cluster in the view in which the hit removal process will run
pParentMuon	the address of the parent cosmic ray pfo
minDistanceFromMuon	the minimum distance of a hit from the cosmic ray track required for removal
maxDistanceToCollected	the maximim distance of a hit from the projected delta ray hits required for removal
collectedHits	the list of hits to be removed from the cosmic ray

Returns: a status code reflecting whether the procedure ran smoothly and if the outcome is good

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::CollectHitsFromMuon	(	const pandora::CartesianVector &	positionOnMuon,
		const pandora::CartesianVector &	muonDirection,
		const pandora::Cluster *const	pMuonCluster,
		const pandora::CartesianPointVector &	deltaRayProjectedPositions,
		const float &	minDistanceFromMuon,
		const float	maxDistanceToCollected,
		pandora::CaloHitList &	collectedHits
	)		const

In one view, pull out any hits from a cosmic ray cluster that belong to the child delta ray cluster.

Parameters

positionOnMuon	the parameterised cosmic ray position
muonDirection	the parameterised cosmic ray direction
pMuon	the address of the parent cosmic ray pfo
deltaRayProjectedPositions	the projected positions of the delta ray
minDistanceFromMuon	the minimum distance of a hit from the cosmic ray track required for removal
maxDistanceToCollected	the maximim distance of a hit from the projected delta ray hits required for removal
collectedHits	the list of hits to be removed from the cosmic ray

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::CollectStrayClusters	(	const pandora::Cluster *const	pClusterToEnlarge,
		const float	rangeMinX,
		const float	rangeMaxX,
		pandora::ClusterList &	collectedClusters
	)

protected

Collect the stray clusters that are close to a specified cluster and that lie within a given x range.

Parameters

pClusterToEnlarge	the specified cluster
rangeMinX	the minimum x coordinate of the region of interest
rangeMaxX	the maximum x coordinate of the region of interest
collectedClusters	the list of collected stray clusters

Definition at line 780 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     const HitType hitType(LArClusterHelper::GetClusterHitType(pClusterToEnlarge));
     const ClusterList &strayClusterList((hitType == TPC_VIEW_U) ? m_strayClusterListU : (hitType == TPC_VIEW_V) ? m_strayClusterListV : m_strayClusterListW);
     const DeltaRayMatchingContainers::ClusterProximityMap &clusterProximityMap(m_deltaRayMatchingContainers.GetClusterProximityMap(hitType));
     const DeltaRayMatchingContainers::ClusterProximityMap::const_iterator clusterProximityIter(clusterProximityMap.find(pClusterToEnlarge));
 
     if (clusterProximityIter == clusterProximityMap.end())
         return;
 
     for (const Cluster *const pNearbyCluster : clusterProximityIter->second)
     {
         if (std::find(strayClusterList.begin(), strayClusterList.end(), pNearbyCluster) == strayClusterList.end())
             continue;
 
         float xMin(-std::numeric_limits<float>::max()), xMax(+std::numeric_limits<float>::max());
         pNearbyCluster->GetClusterSpanX(xMin, xMax);
 
         if (!(((xMin > rangeMinX) && (xMin < rangeMaxX)) || ((xMax > rangeMinX) && (xMax < rangeMaxX))))
             continue;
 
         if (LArClusterHelper::GetClosestDistance(pClusterToEnlarge, pNearbyCluster) > m_strayClusterSeparation)
             continue;
 
         if (std::find(collectedClusters.begin(), collectedClusters.end(), pNearbyCluster) == collectedClusters.end())
             collectedClusters.push_back(pNearbyCluster);
     }
 }

template<typename T >

bool lar_content::NViewDeltaRayMatchingAlgorithm< T >::CreatePfos ( ProtoParticleVector & protoParticleVector )

Create delta ray pfos maxmising completeness by searching for and merging in any stray clusters.

Parameters

protoParticleVector the proto particle vector

Returns: whether any pfos were created

Definition at line 731 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     std::sort(protoParticleVector.begin(), protoParticleVector.end(), [](const ProtoParticle &a, const ProtoParticle &b) -> bool {
         unsigned int aHitTotal(0);
         for (const Cluster *const pCluster : a.m_clusterList)
             aHitTotal += pCluster->GetNCaloHits();
 
         unsigned int bHitTotal(0);
         for (const Cluster *const pCluster : b.m_clusterList)
             bHitTotal += pCluster->GetNCaloHits();
 
         return (aHitTotal > bHitTotal);
     });
 
     for (ProtoParticle protoParticle : protoParticleVector)
     {
         float longestSpan(-std::numeric_limits<float>::max()), spanMinX(0.f), spanMaxX(0.f);
 
         for (const Cluster *const pCluster : protoParticle.m_clusterList)
         {
             float minX(0.f), maxX(0.f);
             pCluster->GetClusterSpanX(minX, maxX);
 
             const float span(maxX - minX);
 
             if (span > longestSpan)
             {
                 longestSpan = span;
                 spanMinX = minX;
                 spanMaxX = maxX;
             }
         }
 
         for (const Cluster *const pCluster : protoParticle.m_clusterList)
         {
             ClusterList collectedClusters;
             this->CollectStrayClusters(pCluster, spanMinX, spanMaxX, collectedClusters);
 
             if (!collectedClusters.empty())
                 this->AddInStrayClusters(pCluster, collectedClusters);
         }
     }
 
     return (this->CreateThreeDParticles(protoParticleVector));
 }

template<typename T>

virtual bool lar_content::NViewDeltaRayMatchingAlgorithm< T >::DoesClusterPassTensorThreshold ( const pandora::Cluster *const pCluster ) const

protectedpure virtual

To check whether a given cluster meets the requirements to be added into the matching container (tensor/matrix)

Parameters

pCluster the address of the input cluster

Returns: whether the checks were met

Implemented in lar_content::TwoViewDeltaRayMatchingAlgorithm, and lar_content::ThreeViewDeltaRayMatchingAlgorithm.

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::FillStrayClusterList ( const pandora::HitType hitType )

protected

Fill the stray cluster list with clusters that do not pass the tensor threshold requirement.

Parameters

hitType the hit type of the list to fill

Definition at line 84 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     const ClusterList &inputClusterList(this->GetInputClusterList(hitType));
     ClusterList &strayClusterList((hitType == TPC_VIEW_U) ? m_strayClusterListU : (hitType == TPC_VIEW_V) ? m_strayClusterListV : m_strayClusterListW);
 
     for (const Cluster *const pCluster : inputClusterList)
     {
         if ((pCluster->IsAvailable()) && (!this->DoesClusterPassTensorThreshold(pCluster)))
             strayClusterList.push_back(pCluster);
     }
 }

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::GetClusterSpanX	(	const pandora::CaloHitList &	caloHitList,
		float &	xMin,
		float &	xMax
	)		const

protected

Calculate the xSpan of a list of CaloHits.

Parameters

caloHitList	the input list of CaloHits
xMin	the output minimum x coordinate
xMax	the output maximum x coordinate

Definition at line 397 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     xMin = std::numeric_limits<float>::max();
     xMax = -std::numeric_limits<float>::max();
 
     for (const CaloHit *const pCaloHit : caloHitList)
     {
         const float xCoordinate(pCaloHit->GetPositionVector().GetX());
 
         if (xCoordinate < xMin)
             xMin = xCoordinate;
 
         if (xCoordinate > xMax)
             xMax = xCoordinate;
     }
 }

template<typename T>

StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::GetClusterSpanZ	(	const pandora::CaloHitList &	caloHitList,
		const float	xMin,
		const float	xMax,
		float &	zMin,
		float &	zMax
	)		const

protected

Calculate the zSpan of a list of CaloHits in a specified x range.

Parameters

caloHitList	the input list of CaloHits
xMin	the minimum x coordinate of the region of interest
xMax	the maximum x coordinate of the region of interest
zMin	the output minimum z coordinate
zMax	the output maximum z coordinate

Definition at line 417 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     zMin = std::numeric_limits<float>::max();
     zMax = -std::numeric_limits<float>::max();
 
     bool found(false);
     for (const CaloHit *const pCaloHit : caloHitList)
     {
         const float xCoordinate(pCaloHit->GetPositionVector().GetX());
         const float zCoordinate(pCaloHit->GetPositionVector().GetZ());
 
         if ((xCoordinate < xMin) || (xCoordinate > xMax))
             continue;
 
         found = true;
 
         if (zCoordinate < zMin)
             zMin = zCoordinate;
 
         if (zCoordinate > zMax)
             zMax = zCoordinate;
     }
 
     if (!found)
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     return STATUS_CODE_SUCCESS;
 }

template<typename T>

StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::GetMuonCluster	(	const pandora::PfoList &	commonMuonPfoList,
		const pandora::HitType	hitType,
		const pandora::Cluster *&	pMuonCluster
	)		const

Return the cluster of the common cosmic ray pfo in a given view (function demands there to be only one common CR pfo)

Parameters

commonMuonPfoList	the element's list of common muon pfos
hitType	the specified view
pMuonCluster	the output address of the cluster

Returns: a status code reflecting if one and only one cosmic ray cluster was found

Definition at line 99 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     if (commonMuonPfoList.size() != 1)
         return STATUS_CODE_NOT_FOUND;
 
     ClusterList muonClusterList;
     LArPfoHelper::GetClusters(commonMuonPfoList.front(), hitType, muonClusterList);
 
     if (muonClusterList.size() != 1)
         return STATUS_CODE_NOT_FOUND;
 
     pMuonCluster = muonClusterList.front();
 
     return STATUS_CODE_SUCCESS;
 }

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::GetNearbyMuonPfos	(	const pandora::Cluster *const	pCluster,
		pandora::ClusterList &	consideredClusters,
		pandora::PfoList &	nearbyMuonPfos
	)		const

protected

Use the cluster proximity map to travel along paths of nearby clusters finding the cosmic ray clusters on which they terminate.

Parameters

pCluster	the address of the input cluster
consideredClusters	the list of investigated clusters
nearbyMuonPfos	the output list of the cosmic ray pfos to which the nearby cosmic ray clusters belong

Definition at line 118 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
     const DeltaRayMatchingContainers::ClusterToPfoMap &clusterToPfoMap(m_deltaRayMatchingContainers.GetClusterToPfoMap(hitType));
     const DeltaRayMatchingContainers::ClusterProximityMap &clusterProximityMap(m_deltaRayMatchingContainers.GetClusterProximityMap(hitType));
 
     consideredClusters.push_back(pCluster);
 
     const DeltaRayMatchingContainers::ClusterProximityMap::const_iterator clusterProximityIter(clusterProximityMap.find(pCluster));
 
     if (clusterProximityIter == clusterProximityMap.end())
         return;
 
     for (const Cluster *const pNearbyCluster : clusterProximityIter->second)
     {
         if (std::find(consideredClusters.begin(), consideredClusters.end(), pNearbyCluster) != consideredClusters.end())
             continue;
 
         const DeltaRayMatchingContainers::ClusterToPfoMap::const_iterator pfoIter(clusterToPfoMap.find(pNearbyCluster));
 
         if (pfoIter != clusterToPfoMap.end())
         {
             if (std::find(nearbyMuonPfos.begin(), nearbyMuonPfos.end(), pfoIter->second) == nearbyMuonPfos.end())
                 nearbyMuonPfos.push_back(pfoIter->second);
 
             continue;
         }
 
         this->GetNearbyMuonPfos(pNearbyCluster, consideredClusters, nearbyMuonPfos);
     }
 }

template<typename T>

StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::GetProjectedPositions	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		pandora::CartesianPointVector &	projectedPositions
	)		const

Use two clusters from different views to calculate projected positions in the remaining third view.

Parameters

pCluster1	the address of the first cluster
pCluster2	the address of the second cluster
projectedPositions	the output projected positions

Returns: a status code reflecting whether the procedure ran smoothly and if the outcome is good

Definition at line 471 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     float xMin1(0.f), xMax1(0.f), xMin2(0.f), xMax2(0.f);
     pCluster1->GetClusterSpanX(xMin1, xMax1);
     pCluster2->GetClusterSpanX(xMin2, xMax2);
 
     const float xPitch(0.5 * m_xOverlapWindow);
     const float xMin(std::max(xMin1, xMin2) - xPitch);
     const float xMax(std::min(xMax1, xMax2) + xPitch);
     const float xOverlap(xMax - xMin);
 
     if (xOverlap < std::numeric_limits<float>::epsilon())
         return STATUS_CODE_NOT_FOUND;
 
     const HitType hitType1(LArClusterHelper::GetClusterHitType(pCluster1));
     const HitType hitType2(LArClusterHelper::GetClusterHitType(pCluster2));
 
     if (hitType1 == hitType2)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     const unsigned int nPoints(1 + static_cast<unsigned int>(xOverlap / xPitch));
 
     // Projection into third view
     for (unsigned int n = 0; n < nPoints; ++n)
     {
         const float x(xMin + (xMax - xMin) * (static_cast<float>(n) + 0.5f) / static_cast<float>(nPoints));
         const float xmin(x - xPitch);
         const float xmax(x + xPitch);
 
         try
         {
             float zMin1(0.f), zMin2(0.f), zMax1(0.f), zMax2(0.f);
             pCluster1->GetClusterSpanZ(xmin, xmax, zMin1, zMax1);
             pCluster2->GetClusterSpanZ(xmin, xmax, zMin2, zMax2);
 
             const float z1(0.5f * (zMin1 + zMax1));
             const float z2(0.5f * (zMin2 + zMax2));
 
             float chi2;
             CartesianVector projection(0.f, 0.f, 0.f);
             LArGeometryHelper::MergeTwoPositions(
                 this->GetPandora(), hitType1, hitType2, CartesianVector(x, 0.f, z1), CartesianVector(x, 0.f, z2), projection, chi2);
 
             projectedPositions.push_back(projection);
         }
         catch (StatusCodeException &statusCodeException)
         {
             if (statusCodeException.GetStatusCode() != STATUS_CODE_NOT_FOUND)
                 throw statusCodeException.GetStatusCode();
 
             continue;
         }
     }
 
     // Reject if projection is not good
     if (projectedPositions.size() < m_minProjectedPositions)
         return STATUS_CODE_NOT_FOUND;
 
     return STATUS_CODE_SUCCESS;
 }

template<typename T>

pandora::StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::ParameteriseMuon	(	const pandora::ParticleFlowObject *const	pParentMuon,
		const pandora::Cluster *const	pDeltaRayCluster,
		pandora::CartesianVector &	positionOnMuon,
		pandora::CartesianVector &	muonDirection
	)		const

Parameterise the projection of a cosmic ray track in order to avoid poor/sparse projections.

Parameters

pParentMuon	the address of the cosmic ray pfo
pDeltaRayCluster	the address of the delta ray cluster in the projected view
positionOnMuon	the output position to localise the parameterisation in space
muonDirection	the output cosmic ray direction

Returns: a status code reflecting whether the procedure ran smoothly and if the outcome is good

template<typename T>

pandora::StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::ParameteriseMuon	(	const pandora::ParticleFlowObject *const	pParentMuon,
		const pandora::CartesianPointVector &	deltaRayProjectedPositions,
		const pandora::HitType	hitType,
		pandora::CartesianVector &	positionOnMuon,
		pandora::CartesianVector &	muonDirection
	)		const

Parameterise the projection of a cosmic ray track in order to avoid poor/sparse projections.

Parameters

pParentMuon	the address of the cosmic ray pfo
deltaRayProjectedPositions	the projected positions of the delta ray
hitType	the view in which the projection is made
positionOnMuon	the output position to localise the parameterisation in space
muonDirection	the output cosmic ray direction

Returns: a status code reflecting whether the procedure ran smoothly and if the outcome is good

template<typename T>

pandora::StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::PerformThreeViewMatching	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		const pandora::Cluster *const	pCluster3,
		float &	reducedChiSquared
	)		const

To determine how well three clusters (one in each view) map onto one another expressing this in terms of a chi-squared like parameter.

Parameters

pCluster1	the first cluster
pCluster2	the second cluster
pCluster3	the third cluster
reducedChiSquared	the reduced chi squared

Returns: a status code reflecting whether the matching procedure ran smoothly and if the outcome is good

template<typename T>

pandora::StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::PerformThreeViewMatching	(	const pandora::Cluster *const	pClusterU,
		const pandora::Cluster *const	pClusterV,
		const pandora::Cluster *const	pClusterW,
		float &	chiSquaredSum,
		unsigned int &	nSamplingPoints,
		unsigned int &	nMatchedSamplingPoints,
		XOverlap &	XOverlap
	)		const

To determine how well three clusters (one in each view) map onto one another expressing this in terms of a chi-squared like parameter.

Parameters

pClusterU	the U cluster (if the xOverlap object is to be retained this must be the u cluster - for labels to make sense)
pClusterV	the V cluster
pClusterW	the W cluster
chiSquaredSum	the sum of the chi-squared values of the sampled points
nSamplingPoints	the number of sampled points
nMatchedSamplingPoints	the number of matched sampled points
xOverlap	the xOverlap object

Returns: a status code reflecting whether the matching procedure ran smoothly and if the outcome is good

template<typename T>

pandora::StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::PerformThreeViewMatching	(	const pandora::CaloHitList &	pCluster1,
		const pandora::CaloHitList &	pCluster2,
		const pandora::CaloHitList &	pCluster3,
		float &	reducedChiSquared
	)		const

To determine how well three CaloHitLists (one in each view) map onto one another expressing this in terms of a chi-squared like parameter.

Parameters

pCluster1	the first CaloHitList
pCluster2	the second CaloHitList
pCluster3	the third CaloHitList
reducedChiSquared	the reduced chi squared

Returns: a status code reflecting whether the matching procedure ran smoothly and if the outcome is good

template<typename T>

pandora::StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::PerformThreeViewMatching	(	const pandora::CaloHitList &	clusterU,
		const pandora::CaloHitList &	clusterV,
		const pandora::CaloHitList &	clusterW,
		float &	chiSquaredSum,
		unsigned int &	nSamplingPoints,
		unsigned int &	nMatchedSamplingPoints,
		XOverlap &	XOverlap
	)		const

To determine how well three CaloHitLists (one for each view) map onto one another expressing this in terms of a chi-squared like parameter.

Parameters

clusterU	the U CaloHitList (if the xOverlap object is to be retained this must be the u cluster - for labels to make sense)
clusterV	the V CaloHitList
clusterW	the W CaloHitList
chiSquaredSum	the sum of the chi-squared values of the sampled points
nSamplingPoints	the number of sampled points
nMatchedSamplingPoints	the number of matched sampled points
xOverlap	the xOverlap object

Returns: a status code reflecting whether the matching procedure ran smoothly and if the outcome is good

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::PrepareInputClusters ( pandora::ClusterList & preparedClusterList )

virtual

Perform any preparatory steps required on the input clusters, e.g. caching expensive fit results.

Parameters

preparedClusterList to receive the prepared cluster list, non const so as to be able to modify input selected list

Reimplemented from lar_content::MatchingBaseAlgorithm.

Definition at line 61 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     if (preparedClusterList.empty())
         return;
 
     const PfoList *pMuonPfoList(nullptr);
 
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, m_muonPfoListName, pMuonPfoList));
 
     if ((!pMuonPfoList) || pMuonPfoList->empty())
         return;
 
     const HitType hitType(LArClusterHelper::GetClusterHitType(preparedClusterList.front()));
 
     m_deltaRayMatchingContainers.FillContainers(*pMuonPfoList, this->GetInputClusterList(hitType));
 
     this->FillStrayClusterList(LArClusterHelper::GetClusterHitType(preparedClusterList.front()));
 }

template<typename T>

StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::ProjectMuonPositions	(	const pandora::HitType &	thirdViewHitType,
		const pandora::ParticleFlowObject *const	pParentMuon,
		pandora::CartesianPointVector &	projectedPositions
	)		const

Use two views of a cosmic ray pfo to calculate projected positions in a given the third view.

Parameters

thirdViewHitType	the view to be projected into
pParentMuon	the input cosmic ray pfo
projectedPositions	the output projected positions

Returns: a status code reflecting whether the procedure ran smoothly and if the outcome is good

Definition at line 450 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     ClusterList muonClusterList1, muonClusterList2;
 
     HitTypeVector hitTypes({TPC_VIEW_U, TPC_VIEW_V, TPC_VIEW_W});
 
     hitTypes.erase(std::find(hitTypes.begin(), hitTypes.end(), thirdViewHitType));
 
     LArPfoHelper::GetClusters(pParentMuon, hitTypes[0], muonClusterList1);
     LArPfoHelper::GetClusters(pParentMuon, hitTypes[1], muonClusterList2);
 
     if ((muonClusterList1.size() != 1) || (muonClusterList2.size() != 1))
         return STATUS_CODE_NOT_FOUND;
 
     return (this->GetProjectedPositions(muonClusterList1.front(), muonClusterList2.front(), projectedPositions));
 }

template<typename T>

StatusCode lar_content::NViewDeltaRayMatchingAlgorithm< T >::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

protectedvirtual

Reimplemented from lar_content::NViewMatchingAlgorithm< T >.

Definition at line 885 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "MuonPfoListName", m_muonPfoListName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "SearchRegion1D", m_deltaRayMatchingContainers.m_searchRegion1D));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PseudoChi2Cut", m_pseudoChi2Cut));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "OverlapWindow", m_xOverlapWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinMatchedFraction", m_minMatchedFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinMatchedPoints", m_minMatchedPoints));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinProjectedPositions", m_minProjectedPositions));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxCosmicRayHitFraction", m_maxCosmicRayHitFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxDistanceToCluster", m_maxDistanceToCluster));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxDistanceToReferencePoint", m_maxDistanceToReferencePoint));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "StrayClusterSeparation", m_strayClusterSeparation));
 
     return NViewMatchingAlgorithm<T>::ReadSettings(xmlHandle);
 }

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::SelectInputClusters	(	const pandora::ClusterList *const	pInputClusterList,
		pandora::ClusterList &	selectedClusterList
	)		const

virtual

Select a subset of input clusters for processing in this algorithm.

Parameters

pInputClusterList	address of an input cluster list
selectedClusterList	to receive the selected cluster list

Reimplemented from lar_content::MatchingBaseAlgorithm.

Definition at line 49 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     for (const Cluster *const pCluster : *pInputClusterList)
     {
         if ((pCluster->IsAvailable()) && (this->DoesClusterPassTensorThreshold(pCluster)))
             selectedClusterList.push_back(pCluster);
     }
 }

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::SplitMuonCluster	(	const std::string &	clusterListName,
		const pandora::Cluster *const	pMuonCluster,
		const pandora::CaloHitList &	collectedHits,
		const pandora::Cluster *&	pDeltaRayCluster
	)		const

Move a list of hits from a cosmic ray cluster into the given child delta ray cluster.

Parameters

clusterListName	the pandora list to which the cosmic ray and delta ray clusters belong
pMuonCluster	the address of the cosmic ray cluster
collectedHits	the list of hits to reassign
pDeltaRayCluster	the address of the delta ray cluster (may be a nullptr if cluster is yet to be made)

Definition at line 691 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*this, clusterListName));
 
     CaloHitList muonCaloHitList;
     pMuonCluster->GetOrderedCaloHitList().FillCaloHitList(muonCaloHitList);
 
     for (const CaloHit *const pCaloHit : muonCaloHitList)
     {
         if (std::find(collectedHits.begin(), collectedHits.end(), pCaloHit) != collectedHits.end())
         {
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::RemoveFromCluster(*this, pMuonCluster, pCaloHit));
 
             if (!pDeltaRayCluster)
             {
                 const ClusterList *pTemporaryList(nullptr);
                 std::string temporaryListName, currentListName;
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentListName<Cluster>(*this, currentListName));
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
                     PandoraContentApi::CreateTemporaryListAndSetCurrent<ClusterList>(*this, pTemporaryList, temporaryListName));
 
                 PandoraContentApi::Cluster::Parameters parameters;
                 parameters.m_caloHitList.push_back(pCaloHit);
 
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pDeltaRayCluster));
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Cluster>(*this, temporaryListName, currentListName));
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*this, currentListName));
             }
             else
             {
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pDeltaRayCluster, pCaloHit));
             }
         }
     }
 }

template<typename T >

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::TidyUp ( )

protectedvirtual

Tidy member variables in derived class.

Reimplemented from lar_content::NViewMatchingAlgorithm< T >.

Definition at line 871 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     m_deltaRayMatchingContainers.ClearContainers();
 
     m_strayClusterListU.clear();
     m_strayClusterListV.clear();
     m_strayClusterListW.clear();
 
     return NViewMatchingAlgorithm<T>::TidyUp();
 }

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::UpdateForNewClusters	(	const pandora::ClusterVector &	newClusterVector,
		const pandora::PfoVector &	pfoVector
	)

Add a new cluster to algorithm ownership maps and, if it a delta ray cluster, to the underlying matches container (tensor/matrix)

Parameters

newClusterVector	the vector of clusters to add - the order must match the pfoVector
pfoVector	the vector of cosmic ray pfos to which the new clusters belong (nullptr for delta ray cluster)

Definition at line 853 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     m_deltaRayMatchingContainers.AddClustersToContainers(newClusterVector, pfoVector);
 
     for (unsigned int i = 0; i < newClusterVector.size(); i++)
     {
         const Cluster *const pNewCluster(newClusterVector.at(i));
         const ParticleFlowObject *const pMuonPfo(pfoVector.at(i));
 
         // ATTN: Only add delta ray clusters into the tensor
         if (!pMuonPfo)
             NViewMatchingAlgorithm<T>::UpdateForNewCluster(pNewCluster);
     }
 }

template<typename T>

void lar_content::NViewDeltaRayMatchingAlgorithm< T >::UpdateUponDeletion ( const pandora::Cluster *const pDeletedCluster )

virtual

Update to reflect cluster deletion.

Parameters

pDeletedCluster address of the deleted cluster

Implements lar_content::MatchingBaseAlgorithm.

Definition at line 832 of file NViewDeltaRayMatchingAlgorithm.cc.

 {
     const HitType hitType(LArClusterHelper::GetClusterHitType(pDeletedCluster));
     ClusterList &strayClusterList((hitType == TPC_VIEW_U) ? m_strayClusterListU : (hitType == TPC_VIEW_V) ? m_strayClusterListV : m_strayClusterListW);
     const ClusterList::const_iterator strayClusterIter(std::find(strayClusterList.begin(), strayClusterList.end(), pDeletedCluster));
 
     if (strayClusterIter != strayClusterList.end())
         strayClusterList.erase(strayClusterIter);
 
     const DeltaRayMatchingContainers::ClusterToPfoMap &clusterToPfoMap(m_deltaRayMatchingContainers.GetClusterToPfoMap(hitType));
     const bool isMuonCluster(clusterToPfoMap.find(pDeletedCluster) != clusterToPfoMap.end());
 
     m_deltaRayMatchingContainers.RemoveClusterFromContainers(pDeletedCluster);
 
     if (!isMuonCluster)
         NViewMatchingAlgorithm<T>::UpdateUponDeletion(pDeletedCluster);
 }