ThreeDTrackFragmentsAlgorithm class. More...

#include "ThreeDTrackFragmentsAlgorithm.h"

Inheritance diagram for lar_content::ThreeDTrackFragmentsAlgorithm:

Public Types
typedef OverlapTensor< FragmentOverlapResult >	TensorType

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

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

void	RebuildClusters (const pandora::ClusterList &rebuildList, pandora::ClusterList &newClusters) const
	Rebuild clusters after fragmentation. More...

const TwoDSlidingFitResult &	GetCachedSlidingFitResult (const pandora::Cluster *const pCluster) const
	Get a sliding fit result from the algorithm cache. More...

unsigned int	GetSlidingFitWindow () const
	Get the layer window for the sliding linear fits. More...

virtual bool	MakeClusterSplits (const SplitPositionMap &splitPositionMap)
	Make cluster splits. More...

virtual bool	MakeClusterSplit (const pandora::CartesianVector &splitPosition, const pandora::Cluster &pCurrentCluster, const pandora::Cluster &pLowXCluster, const pandora::Cluster *&pHighXCluster) const
	Make a cluster split. More...

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

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

virtual void	SetPfoParameters (const ProtoParticle &protoParticle, PandoraContentApi::ParticleFlowObject::Parameters &pfoParameters) const
	Calculate Pfo properties from proto particle. More...

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

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

virtual void	RemoveUnavailableTensorElements ()
	Update tensor to remove all elements that have been added to pfos and so are unavailable. More...

const pandora::ClusterList &	GetInputClusterListU () const
	Get the input u cluster list. More...

const pandora::ClusterList &	GetInputClusterListV () const
	Get the input v cluster list. More...

const pandora::ClusterList &	GetInputClusterListW () const
	Get the input w cluster list. More...

const pandora::ClusterList &	GetSelectedClusterListU () const
	Get the selected u cluster list. More...

const pandora::ClusterList &	GetSelectedClusterListV () const
	Get the selected v cluster list. More...

const pandora::ClusterList &	GetSelectedClusterListW () const
	Get the selected w cluster list. More...

const std::string &	GetClusterListNameU () const
	Get the name of the u cluster list. More...

const std::string &	GetClusterListNameV () const
	Get the name of the v cluster list. More...

const std::string &	GetClusterListNameW () const
	Get the name of the w cluster list. More...

Static Public Member Functions
static bool	SortSplitPositions (const pandora::CartesianVector &lhs, const pandora::CartesianVector &rhs)
	Sort split position cartesian vectors by increasing x coordinate. More...

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

typedef std::unordered_map< const pandora::Cluster *, unsigned int >	ClusterToMatchedHitsMap

typedef std::vector< FragmentTensorTool * >	TensorToolVector

Protected Member Functions
void	PerformMainLoop ()
	Main loop over cluster combinations in order to populate the tensor. Responsible for calling CalculateOverlapResult. More...

void	CalculateOverlapResult (const pandora::Cluster const pClusterU, const pandora::Cluster const pClusterV, const pandora::Cluster *const pClusterW)
	Calculate cluster overlap result and store in tensor. More...

pandora::StatusCode	CalculateOverlapResult (const TwoDSlidingFitResult &fitResult1, const TwoDSlidingFitResult &fitResult2, const pandora::ClusterList &inputClusterList, const pandora::Cluster *&pBestMatchedCluster, FragmentOverlapResult &fragmentOverlapResult) const
	Calculate overlap result for track fragment candidate consisting of two sliding fit results and a list of available clusters. More...

pandora::StatusCode	GetProjectedPositions (const TwoDSlidingFitResult &fitResult1, const TwoDSlidingFitResult &fitResult2, pandora::CartesianPointVector &projectedPositions) const
	Get the list of projected positions, in the third view, corresponding to a pair of sliding fit results. More...

pandora::StatusCode	GetMatchedHits (const pandora::ClusterList &inputClusterList, const pandora::CartesianPointVector &projectedPositions, HitToClusterMap &hitToClusterMap, pandora::CaloHitList &matchedCaloHits) const
	Get the list of hits associated with the projected positions and a useful hit to cluster map. More...

pandora::StatusCode	GetMatchedClusters (const pandora::CaloHitList &matchedHits, const HitToClusterMap &hitToClusterMap, pandora::ClusterList &matchedClusters, const pandora::Cluster *&pBestMatchedCluster) const
	Get the list of the relevant clusters and the address of the single best matched cluster. More...

void	GetFragmentOverlapResult (const pandora::CartesianPointVector &projectedPositions, const pandora::CaloHitList &matchedHits, const pandora::ClusterList &matchedClusters, FragmentOverlapResult &fragmentOverlapResult) const
	Get the populated fragment overlap result. More...

bool	CheckMatchedClusters (const pandora::CartesianPointVector &projectedPositions, const pandora::ClusterList &matchedClusters) const
	Whether the matched clusters are consistent with the projected positions. More...

bool	CheckOverlapResult (const FragmentOverlapResult &overlapResult) const
	Whether the matched clusters and hits pass the algorithm quality cuts. More...

void	ExamineTensor ()
	Examine contents of tensor, collect together best-matching 2D particles and modify clusters as required. More...

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

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

virtual void	PreparationStep (pandora::ClusterList &clusterList)
	Preparation step for a specific cluster list. More...

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

void	AddToSlidingFitCache (const pandora::Cluster *const pCluster)
	Add a new sliding fit result, for the specified cluster, to the algorithm cache. More...

void	RemoveFromSlidingFitCache (const pandora::Cluster *const pCluster)
	Remova an existing sliding fit result, for the specified cluster, from the algorithm cache. More...

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

Protected Attributes
std::string	m_reclusteringAlgorithmName
	Name of daughter algorithm to use for cluster re-building. More...

TensorToolVector	m_algorithmToolVector
	The algorithm tool list. More...

unsigned int	m_nMaxTensorToolRepeats
	The maximum number of repeat loops over tensor tools. More...

float	m_minXOverlap
	requirement on minimum X overlap for associated clusters More...

float	m_minXOverlapFraction
	requirement on minimum X overlap fraction for associated clusters More...

float	m_maxPointDisplacementSquared
	maximum allowed distance (squared) between projected points and associated hits More...

float	m_minMatchedSamplingPointFraction
	minimum fraction of matched sampling points More...

unsigned int	m_minMatchedHits
	minimum number of matched calo hits More...

unsigned int	m_slidingFitWindow
	The layer window for the sliding linear fits. More...

TwoDSlidingFitResultMap	m_slidingFitResultMap
	The sliding fit result map. More...

unsigned int	m_minClusterCaloHits
	The min number of hits in base cluster selection method. More...

float	m_minClusterLengthSquared
	The min length (squared) in base cluster selection method. More...

const pandora::ClusterList *	m_pInputClusterListU
	Address of the input cluster list U. More...

const pandora::ClusterList *	m_pInputClusterListV
	Address of the input cluster list V. More...

const pandora::ClusterList *	m_pInputClusterListW
	Address of the input cluster list W. More...

pandora::ClusterList	m_clusterListU
	The selected modified cluster list U. More...

pandora::ClusterList	m_clusterListV
	The selected modified cluster list V. More...

pandora::ClusterList	m_clusterListW
	The selected modified cluster list W. More...

TensorType	m_overlapTensor
	The overlap tensor. More...

Detailed Description

ThreeDTrackFragmentsAlgorithm class.

Definition at line 30 of file ThreeDTrackFragmentsAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster*, unsigned int> lar_content::ThreeDTrackFragmentsAlgorithm::ClusterToMatchedHitsMap

protected

Definition at line 139 of file ThreeDTrackFragmentsAlgorithm.h.

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

protected

Definition at line 66 of file ThreeDTrackFragmentsAlgorithm.h.

typedef std::vector<FragmentTensorTool*> lar_content::ThreeDTrackFragmentsAlgorithm::TensorToolVector

protected

Definition at line 143 of file ThreeDTrackFragmentsAlgorithm.h.

typedef OverlapTensor<FragmentOverlapResult > lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::TensorType

inherited

Definition at line 45 of file ThreeDBaseAlgorithm.h.

Constructor & Destructor Documentation

lar_content::ThreeDTrackFragmentsAlgorithm::ThreeDTrackFragmentsAlgorithm ( )

Default constructor.

Definition at line 21 of file ThreeDTrackFragmentsAlgorithm.cc.

                                                              :
     m_nMaxTensorToolRepeats(1000),
     m_minXOverlap(3.f),
     m_minXOverlapFraction(0.8f),
     m_maxPointDisplacementSquared(1.5f * 1.5f),
     m_minMatchedSamplingPointFraction(0.5f),
     m_minMatchedHits(5)
 {
 }

Member Function Documentation

void lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::AddToSlidingFitCache ( const pandora::Cluster *const pCluster )

protectedinherited

Add a new sliding fit result, for the specified cluster, to the algorithm cache.

Parameters

pCluster address of the relevant cluster

Referenced by UpdateForNewCluster().

void lar_content::ThreeDTrackFragmentsAlgorithm::CalculateOverlapResult	(	const pandora::Cluster *const	pClusterU,
		const pandora::Cluster *const	pClusterV,
		const pandora::Cluster *const	pClusterW
	)

protectedvirtual

Calculate cluster overlap result and store in tensor.

Parameters

pClusterU	address of U view cluster
pClusterV	address of V view cluster
pClusterW	address of W view cluster

Implements lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >.

Referenced by PerformMainLoop(), and UpdateForNewCluster().

pandora::StatusCode lar_content::ThreeDTrackFragmentsAlgorithm::CalculateOverlapResult	(	const TwoDSlidingFitResult &	fitResult1,
		const TwoDSlidingFitResult &	fitResult2,
		const pandora::ClusterList &	inputClusterList,
		const pandora::Cluster *&	pBestMatchedCluster,
		FragmentOverlapResult &	fragmentOverlapResult
	)		const

protected

Calculate overlap result for track fragment candidate consisting of two sliding fit results and a list of available clusters.

Parameters

fitResult1	the first sliding fit result
fitResult2	the second sliding fit result
inputClusterList	the input cluster list
pBestMatchedCluster	to receive the address of the best matched cluster
fragmentOverlapResult	to receive the populated fragment overlap result

Returns: statusCode, faster than throwing in regular use-cases

bool lar_content::ThreeDTrackFragmentsAlgorithm::CheckMatchedClusters	(	const pandora::CartesianPointVector &	projectedPositions,
		const pandora::ClusterList &	matchedClusters
	)		const

protected

Whether the matched clusters are consistent with the projected positions.

Parameters

projectedPositions	the list of projected positions
matchedClusters	the list of matched clusters

Returns: boolean

Definition at line 543 of file ThreeDTrackFragmentsAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetClusterBoundingBox(), max, and min.

Referenced by PerformMainLoop().

 {
     if (projectedPositions.empty() || matchedClusters.empty())
         return false;
 
     // Calculate X and Z span of projected positions
     float minXproj(+std::numeric_limits<float>::max());
     float maxXproj(-std::numeric_limits<float>::max());
     float minZproj(+std::numeric_limits<float>::max());
     float maxZproj(-std::numeric_limits<float>::max());
 
     for (const CartesianVector &projectedPosition : projectedPositions)
     {
         minXproj = std::min(minXproj, projectedPosition.GetX());
         maxXproj = std::max(maxXproj, projectedPosition.GetX());
         minZproj = std::min(minZproj, projectedPosition.GetZ());
         maxZproj = std::max(maxZproj, projectedPosition.GetZ());
     }
 
     const float dXproj(maxXproj - minXproj);
     const float dZproj(maxZproj - minZproj);
     const float projectedLengthSquared(dXproj * dXproj + dZproj * dZproj);
 
     // Calculate X and Z span of matched clusters
     float minXcluster(+std::numeric_limits<float>::max());
     float maxXcluster(-std::numeric_limits<float>::max());
     float minZcluster(+std::numeric_limits<float>::max());
     float maxZcluster(-std::numeric_limits<float>::max());
 
     for (const Cluster *const pCluster : matchedClusters)
     {
         CartesianVector minPosition(0.f,0.f,0.f);
         CartesianVector maxPosition(0.f,0.f,0.f);
 
         LArClusterHelper::GetClusterBoundingBox(pCluster, minPosition, maxPosition);
 
         minXcluster = std::min(minXcluster, minPosition.GetX());
         maxXcluster = std::max(maxXcluster, maxPosition.GetX());
         minZcluster = std::min(minZcluster, minPosition.GetZ());
         maxZcluster = std::max(maxZcluster, maxPosition.GetZ());
     }
 
     const float dXcluster(maxXcluster - minXcluster);
     const float dZcluster(maxZcluster - minZcluster);
     const float clusterLengthSquared(dXcluster * dXcluster + dZcluster * dZcluster);
 
     // Require that the span of the matched clusters is no larger than twice the span of the projected positions
     if (clusterLengthSquared > 4.f * projectedLengthSquared)
         return false;
 
     return true;
 }

bool lar_content::ThreeDTrackFragmentsAlgorithm::CheckOverlapResult ( const FragmentOverlapResult & overlapResult ) const

protected

Whether the matched clusters and hits pass the algorithm quality cuts.

Parameters

fragmentOverlapResult the fragment overlap result

Returns: boolean

Definition at line 598 of file ThreeDTrackFragmentsAlgorithm.cc.

References lar_content::FragmentOverlapResult::GetFragmentCaloHitList(), lar_content::TrackOverlapResult::GetMatchedFraction(), m_minMatchedHits, and m_minMatchedSamplingPointFraction.

Referenced by PerformMainLoop().

 {
     // ATTN This method is currently mirrored in ClearTrackFragments tool
     if (overlapResult.GetMatchedFraction() < m_minMatchedSamplingPointFraction)
         return false;
 
     if (overlapResult.GetFragmentCaloHitList().size() < m_minMatchedHits)
         return false;
 
     return true;
 }

virtual bool lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::CreateThreeDParticles ( const ProtoParticleVector & protoParticleVector )

virtualinherited

Create particles using findings from recent algorithm processing.

Parameters

protoParticleVector	the proto particle vector
whether	particles were created

void lar_content::ThreeDTrackFragmentsAlgorithm::ExamineTensor ( )

protectedvirtual

Examine contents of tensor, collect together best-matching 2D particles and modify clusters as required.

Implements lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >.

Definition at line 612 of file ThreeDTrackFragmentsAlgorithm.cc.

References m_algorithmToolVector, m_nMaxTensorToolRepeats, and lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_overlapTensor.

 {
     unsigned int repeatCounter(0);
 
     for (TensorToolVector::const_iterator iter = m_algorithmToolVector.begin(), iterEnd = m_algorithmToolVector.end(); iter != iterEnd; )
     {
         if ((*iter)->Run(this, m_overlapTensor))
         {
             iter = m_algorithmToolVector.begin();
 
             if (++repeatCounter > m_nMaxTensorToolRepeats)
                 break;
         }
         else
         {
             ++iter;
         }
     }
 }

const TwoDSlidingFitResult& lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::GetCachedSlidingFitResult ( const pandora::Cluster *const pCluster ) const

inherited

Get a sliding fit result from the algorithm cache.

Parameters

pCluster address of the relevant cluster

Referenced by PerformMainLoop().

const std::string& lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::GetClusterListNameU ( ) const

inherited

Get the name of the u cluster list.

const std::string& lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::GetClusterListNameV ( ) const

inherited

Get the name of the v cluster list.

const std::string& lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::GetClusterListNameW ( ) const

inherited

Get the name of the w cluster list.

void lar_content::ThreeDTrackFragmentsAlgorithm::GetFragmentOverlapResult	(	const pandora::CartesianPointVector &	projectedPositions,
		const pandora::CaloHitList &	matchedHits,
		const pandora::ClusterList &	matchedClusters,
		FragmentOverlapResult &	fragmentOverlapResult
	)		const

protected

Get the populated fragment overlap result.

Parameters

projectedPositions	the list of projected positions
matchedHits	the list of matched hits
matchedClusters	the list of matched clusters
fragmentOverlapResult	to receive the populated fragment overlap result

Definition at line 510 of file ThreeDTrackFragmentsAlgorithm.cc.

References f, m_maxPointDisplacementSquared, max, and lar_content::LArClusterHelper::SortHitsByPosition().

Referenced by PerformMainLoop().

 {
     float chi2Sum(0.f);
     unsigned int nMatchedSamplingPoints(0);
 
     CaloHitVector sortedMatchedHits(matchedHits.begin(), matchedHits.end());
     std::sort(sortedMatchedHits.begin(), sortedMatchedHits.end(), LArClusterHelper::SortHitsByPosition);
 
     for (const CartesianVector &projectedPosition : projectedPositions)
     {
         float closestDistanceSquared(std::numeric_limits<float>::max());
 
         for (const CaloHit *const pCaloHit : matchedHits)
         {
             const float distanceSquared((pCaloHit->GetPositionVector() - projectedPosition).GetMagnitudeSquared());
 
             if (distanceSquared < closestDistanceSquared)
                 closestDistanceSquared = distanceSquared;
         }
 
         if (closestDistanceSquared < m_maxPointDisplacementSquared)
         {
             ++nMatchedSamplingPoints;
             chi2Sum += closestDistanceSquared;
         }
     }
 
     fragmentOverlapResult = FragmentOverlapResult(nMatchedSamplingPoints, projectedPositions.size(), chi2Sum, matchedHits, matchedClusters);
 }

const pandora::ClusterList& lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::GetInputClusterListU ( ) const

inherited

Get the input u cluster list.

Referenced by PerformMainLoop().

const pandora::ClusterList& lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::GetInputClusterListV ( ) const

inherited

Get the input v cluster list.

Referenced by PerformMainLoop().

const pandora::ClusterList& lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::GetInputClusterListW ( ) const

inherited

Get the input w cluster list.

Referenced by PerformMainLoop().

StatusCode lar_content::ThreeDTrackFragmentsAlgorithm::GetMatchedClusters	(	const pandora::CaloHitList &	matchedHits,
		const HitToClusterMap &	hitToClusterMap,
		pandora::ClusterList &	matchedClusters,
		const pandora::Cluster *&	pBestMatchedCluster
	)		const

protected

Get the list of the relevant clusters and the address of the single best matched cluster.

Parameters

matchedHits	the list of matched calo hits
hitToClusterMap	the hit to cluster map
matchedClusters	to receive the list of matched clusters
pBestMatchedCluster	to receive the address of the single best matched cluster

Returns: statusCode, faster than throwing in regular use-cases

Definition at line 460 of file ThreeDTrackFragmentsAlgorithm.cc.

References f, and lar_content::LArClusterHelper::SortByNHits().

Referenced by PerformMainLoop().

 {
     ClusterToMatchedHitsMap clusterToMatchedHitsMap;
 
     for (CaloHitList::const_iterator iter = matchedHits.begin(), iterEnd = matchedHits.end(); iter != iterEnd; ++iter)
     {
         const CaloHit *const pCaloHit = *iter;
         HitToClusterMap::const_iterator cIter = hitToClusterMap.find(pCaloHit);
 
         if (hitToClusterMap.end() == cIter)
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         ++clusterToMatchedHitsMap[cIter->second];
 
         if (matchedClusters.end() == std::find(matchedClusters.begin(), matchedClusters.end(), cIter->second))
             matchedClusters.push_back(cIter->second);
     }
 
     if (matchedClusters.empty())
         return STATUS_CODE_NOT_FOUND;
 
     pBestMatchedCluster = NULL;
     unsigned int bestClusterMatchedHits(0);
     float tieBreakerBestEnergy(0.f);
 
     ClusterVector sortedClusters;
     for (const auto &mapEntry : clusterToMatchedHitsMap) sortedClusters.push_back(mapEntry.first);
     std::sort(sortedClusters.begin(), sortedClusters.end(), LArClusterHelper::SortByNHits);
 
     for (const Cluster *const pCluster : sortedClusters)
     {
         const unsigned int nMatchedHits(clusterToMatchedHitsMap.at(pCluster));
 
         if ((nMatchedHits > bestClusterMatchedHits) || ((nMatchedHits == bestClusterMatchedHits) && (pCluster->GetHadronicEnergy() > tieBreakerBestEnergy)))
         {
             pBestMatchedCluster = pCluster;
             bestClusterMatchedHits = nMatchedHits;
             tieBreakerBestEnergy = pCluster->GetHadronicEnergy();
         }
     }
 
     if (NULL == pBestMatchedCluster)
         return STATUS_CODE_NOT_FOUND;
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::ThreeDTrackFragmentsAlgorithm::GetMatchedHits	(	const pandora::ClusterList &	inputClusterList,
		const pandora::CartesianPointVector &	projectedPositions,
		HitToClusterMap &	hitToClusterMap,
		pandora::CaloHitList &	matchedCaloHits
	)		const

protected

Get the list of hits associated with the projected positions and a useful hit to cluster map.

Parameters

inputClusterList	the input cluster list
projectedPositions	the list of projected positions
hitToClusterMap	to receive the hit to cluster map
matchedCaloHits	to receive the list of associated calo hits

Returns: statusCode, faster than throwing in regular use-cases

Definition at line 409 of file ThreeDTrackFragmentsAlgorithm.cc.

References f, m_maxPointDisplacementSquared, max, and lar_content::LArClusterHelper::SortHitsByPosition().

Referenced by PerformMainLoop().

 {
     CaloHitVector availableCaloHits;
 
     for (ClusterList::const_iterator iter = inputClusterList.begin(), iterEnd = inputClusterList.end(); iter != iterEnd; ++iter)
     {
         const Cluster *const pCluster = *iter;
 
         if (!pCluster->IsAvailable())
             continue;
 
         CaloHitList caloHitList;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(caloHitList);
         availableCaloHits.insert(availableCaloHits.end(), caloHitList.begin(), caloHitList.end());
 
         for (CaloHitList::const_iterator hIter = caloHitList.begin(), hIterEnd = caloHitList.end(); hIter != hIterEnd; ++hIter)
             hitToClusterMap.insert(HitToClusterMap::value_type(*hIter, pCluster));
     }
 
     std::sort(availableCaloHits.begin(), availableCaloHits.end(), LArClusterHelper::SortHitsByPosition);
 
     for (const CartesianVector &projectedPosition : projectedPositions)
     {
         const CaloHit *pClosestCaloHit(NULL);
         float closestDistanceSquared(std::numeric_limits<float>::max()), tieBreakerBestEnergy(0.f);
 
         for (const CaloHit *const pCaloHit : availableCaloHits)
         {
             const float distanceSquared((pCaloHit->GetPositionVector() - projectedPosition).GetMagnitudeSquared());
 
             if ((distanceSquared < closestDistanceSquared) || ((std::fabs(distanceSquared - closestDistanceSquared) < std::numeric_limits<float>::epsilon()) && (pCaloHit->GetHadronicEnergy() > tieBreakerBestEnergy)))
             {
                 pClosestCaloHit = pCaloHit;
                 closestDistanceSquared = distanceSquared;
                 tieBreakerBestEnergy = pCaloHit->GetHadronicEnergy();
             }
         }
 
         if ((closestDistanceSquared < m_maxPointDisplacementSquared) && (NULL != pClosestCaloHit) && (matchedHits.end() == std::find(matchedHits.begin(), matchedHits.end(), pClosestCaloHit)))
             matchedHits.push_back(pClosestCaloHit);
     }
 
     if (matchedHits.empty())
         return STATUS_CODE_NOT_FOUND;
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::ThreeDTrackFragmentsAlgorithm::GetProjectedPositions	(	const TwoDSlidingFitResult &	fitResult1,
		const TwoDSlidingFitResult &	fitResult2,
		pandora::CartesianPointVector &	projectedPositions
	)		const

protected

Get the list of projected positions, in the third view, corresponding to a pair of sliding fit results.

Parameters

fitResult1	the first sliding fit result
fitResult2	the second sliding fit result
projectedPositions	to receive the list of projected positions

Returns: statusCode, faster than throwing in regular use-cases

Definition at line 268 of file ThreeDTrackFragmentsAlgorithm.cc.

References f, lar_content::TwoDSlidingFitResult::GetCluster(), lar_content::LArClusterHelper::GetClusterHitType(), lar_content::LArClusterHelper::GetClusterSpanX(), lar_content::TwoDSlidingFitResult::GetFitSegment(), lar_content::TwoDSlidingFitResult::GetGlobalFitProjection(), lar_content::TwoDSlidingFitResult::GetGlobalMaxLayerPosition(), lar_content::TwoDSlidingFitResult::GetGlobalMinLayerPosition(), lar_content::TwoDSlidingFitResult::GetLocalPosition(), lar_content::TwoDSlidingFitResult::GetTransverseProjection(), lar_content::LArGeometryHelper::GetWireZPitch(), m_minXOverlap, m_minXOverlapFraction, max, lar_content::LArGeometryHelper::MergeTwoPositions(), lar_content::LArGeometryHelper::MergeTwoPositions3D(), min, lar_content::LArGeometryHelper::ProjectPosition(), and x.

Referenced by PerformMainLoop().

 {
     const Cluster *const pCluster1(fitResult1.GetCluster());
     const Cluster *const pCluster2(fitResult2.GetCluster());
 
     // Check hit types
     const HitType hitType1(LArClusterHelper::GetClusterHitType(pCluster1));
     const HitType hitType2(LArClusterHelper::GetClusterHitType(pCluster2));
     const HitType hitType3((TPC_VIEW_U != hitType1 && TPC_VIEW_U != hitType2) ? TPC_VIEW_U :
                            (TPC_VIEW_V != hitType1 && TPC_VIEW_V != hitType2) ? TPC_VIEW_V :
                            (TPC_VIEW_W != hitType1 && TPC_VIEW_W != hitType2) ? TPC_VIEW_W : HIT_CUSTOM);
 
     if (HIT_CUSTOM == hitType3)
         return STATUS_CODE_INVALID_PARAMETER;
 
     // Check absolute and fractional overlap in x coordinate
     float xMin1(0.f), xMax1(0.f), xMin2(0.f), xMax2(0.f);
     LArClusterHelper::GetClusterSpanX(pCluster1, xMin1, xMax1);
     LArClusterHelper::GetClusterSpanX(pCluster2, xMin2, xMax2);
 
     const float xOverlap(std::min(xMax1, xMax2) - std::max(xMin1, xMin2));
     const float xSpan(std::max(xMax1, xMax2) - std::min(xMin1, xMin2));
 
     if ((xOverlap < m_minXOverlap) || (xSpan < std::numeric_limits<float>::epsilon()) || ((xOverlap / xSpan) < m_minXOverlapFraction))
         return STATUS_CODE_NOT_FOUND;
 
     // Identify vertex and end positions (2D)
     const CartesianVector minPosition1(fitResult1.GetGlobalMinLayerPosition());
     const CartesianVector maxPosition1(fitResult1.GetGlobalMaxLayerPosition());
     const CartesianVector minPosition2(fitResult2.GetGlobalMinLayerPosition());
     const CartesianVector maxPosition2(fitResult2.GetGlobalMaxLayerPosition());
 
     const float dx_A(std::fabs(minPosition2.GetX() - minPosition1.GetX()));
     const float dx_B(std::fabs(maxPosition2.GetX() - maxPosition1.GetX()));
     const float dx_C(std::fabs(maxPosition2.GetX() - minPosition1.GetX()));
     const float dx_D(std::fabs(minPosition2.GetX() - maxPosition1.GetX()));
 
     if (std::min(dx_C,dx_D) > std::max(dx_A,dx_B) && std::min(dx_A,dx_B) > std::max(dx_C,dx_D))
        return STATUS_CODE_NOT_FOUND;
 
     const CartesianVector &vtxPosition1(minPosition1);
     const CartesianVector &endPosition1(maxPosition1);
     const CartesianVector &vtxPosition2((dx_A < dx_C) ? minPosition2 : maxPosition2);
     const CartesianVector &endPosition2((dx_A < dx_C) ? maxPosition2 : minPosition2);
 
     // Calculate vertex and end positions (3D)
     float vtxChi2(0.f);
     CartesianVector vtxPosition3D(0.f, 0.f, 0.f);
     LArGeometryHelper::MergeTwoPositions3D(this->GetPandora(), hitType1, hitType2, vtxPosition1, vtxPosition2, vtxPosition3D, vtxChi2);
 
     float endChi2(0.f);
     CartesianVector endPosition3D(0.f, 0.f, 0.f);
     LArGeometryHelper::MergeTwoPositions3D(this->GetPandora(), hitType1, hitType2, endPosition1, endPosition2, endPosition3D, endChi2);
 
     const CartesianVector vtxProjection3(LArGeometryHelper::ProjectPosition(this->GetPandora(), vtxPosition3D, hitType3));
     const CartesianVector endProjection3(LArGeometryHelper::ProjectPosition(this->GetPandora(), endPosition3D, hitType3));
 
     const float samplingPitch(0.5f * LArGeometryHelper::GetWireZPitch(this->GetPandora()));
     const float nSamplingPoints((endProjection3 - vtxProjection3).GetMagnitude() / samplingPitch);
 
     if (nSamplingPoints < 1.f)
         return STATUS_CODE_NOT_FOUND;
 
     // Loop over trajectory points
     bool foundLastPosition(false);
     CartesianVector lastPosition(0.f,0.f,0.f);
 
     for (float iSample = 0.5f; iSample < nSamplingPoints; iSample += 1.f)
     {
         const CartesianVector linearPosition3D(vtxPosition3D + (endPosition3D - vtxPosition3D) * (iSample / nSamplingPoints));
         const CartesianVector linearPosition1(LArGeometryHelper::ProjectPosition(this->GetPandora(), linearPosition3D, hitType1));
         const CartesianVector linearPosition2(LArGeometryHelper::ProjectPosition(this->GetPandora(), linearPosition3D, hitType2));
 
         float chi2(0.f);
         CartesianVector fitPosition1(0.f, 0.f, 0.f), fitPosition2(0.f, 0.f, 0.f);
 
         if ((STATUS_CODE_SUCCESS != fitResult1.GetGlobalFitProjection(linearPosition1, fitPosition1)) ||
             (STATUS_CODE_SUCCESS != fitResult2.GetGlobalFitProjection(linearPosition2, fitPosition2)))
         {
             continue;
         }
 
         float rL1(0.f), rL2(0.f), rT1(0.f), rT2(0.f);
         fitResult1.GetLocalPosition(fitPosition1, rL1, rT1);
         fitResult2.GetLocalPosition(fitPosition2, rL2, rT2);
 
         const float x(0.5 * (fitPosition1.GetX() + fitPosition2.GetX()));
         CartesianVector position1(0.f, 0.f, 0.f), position2(0.f, 0.f, 0.f), position3(0.f, 0.f, 0.f);
 
         try
         {
             const FitSegment &fitSegment1 = fitResult1.GetFitSegment(rL1);
             const FitSegment &fitSegment2 = fitResult2.GetFitSegment(rL2);
 
             if ((STATUS_CODE_SUCCESS != fitResult1.GetTransverseProjection(x, fitSegment1, position1)) ||
                 (STATUS_CODE_SUCCESS != fitResult2.GetTransverseProjection(x, fitSegment2, position2)))
             {
                 continue;
             }
         }
         catch (StatusCodeException &statusCodeException)
         {
             if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                 throw statusCodeException;
 
             continue;
         }
 
         LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType1, hitType2, position1, position2, position3, chi2);
 
         // TODO For highly multi-valued x, projected positions can be unreliable. Need to make interpolation more robust for these cases.
         if (foundLastPosition)
         {
             const float thisDisplacement((lastPosition - position3).GetMagnitude());
             if (thisDisplacement > 2.f * samplingPitch)
             {
                 const float nExtraPoints(thisDisplacement / samplingPitch);
                 for (float iExtra = 0.5f; iExtra < nExtraPoints; iExtra += 1.f)
                 {
                     const CartesianVector extraPosition(position3 + (lastPosition - position3) * (iExtra / nExtraPoints));
                     projectedPositions.push_back(extraPosition);
                 }
             }
         }
 
         projectedPositions.push_back(position3);
 
         lastPosition = position3;
         foundLastPosition = true;
     }
 
     // Bail out if list of projected positions is empty
     if (projectedPositions.empty())
         return STATUS_CODE_NOT_FOUND;
 
     return STATUS_CODE_SUCCESS;
 }

const pandora::ClusterList& lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::GetSelectedClusterListU ( ) const

inherited

Get the selected u cluster list.

const pandora::ClusterList& lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::GetSelectedClusterListV ( ) const

inherited

Get the selected v cluster list.

const pandora::ClusterList& lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::GetSelectedClusterListW ( ) const

inherited

Get the selected w cluster list.

unsigned int lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::GetSlidingFitWindow ( ) const

inherited

Get the layer window for the sliding linear fits.

Returns: the layer window for the sliding linear fits

virtual bool lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::MakeClusterMerges ( const ClusterMergeMap & clusterMergeMap )

virtualinherited

Merge clusters together.

Parameters

clusterMergeMap the cluster merge map

Returns: whether changes to the tensor have been made

virtual bool lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::MakeClusterSplit	(	const pandora::CartesianVector &	splitPosition,
		const pandora::Cluster *&	pCurrentCluster,
		const pandora::Cluster *&	pLowXCluster,
		const pandora::Cluster *&	pHighXCluster
	)		const

virtualinherited

Make a cluster split.

Parameters

splitPosition	the split position
pCurrentCluster	the cluster to split
pLowXCluster	to receive the low x cluster
pHighXCluster	to receive the high x cluster

Returns: whether a cluster split occurred

virtual bool lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::MakeClusterSplits ( const SplitPositionMap & splitPositionMap )

virtualinherited

Make cluster splits.

Parameters

splitPositionMap the split position map

Returns: whether changes to the tensor have been made

void lar_content::ThreeDTrackFragmentsAlgorithm::PerformMainLoop ( )

protectedvirtual

Main loop over cluster combinations in order to populate the tensor. Responsible for calling CalculateOverlapResult.

Reimplemented from lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >.

Definition at line 118 of file ThreeDTrackFragmentsAlgorithm.cc.

 {
     ClusterVector clusterVectorU(m_clusterListU.begin(), m_clusterListU.end());
     ClusterVector clusterVectorV(m_clusterListV.begin(), m_clusterListV.end());
     ClusterVector clusterVectorW(m_clusterListW.begin(), m_clusterListW.end());
     std::sort(clusterVectorU.begin(), clusterVectorU.end(), LArClusterHelper::SortByNHits);
     std::sort(clusterVectorV.begin(), clusterVectorV.end(), LArClusterHelper::SortByNHits);
     std::sort(clusterVectorW.begin(), clusterVectorW.end(), LArClusterHelper::SortByNHits);
 
     for (const Cluster *const pClusterU : clusterVectorU)
     {
         for (const Cluster *const pClusterV : clusterVectorV)
             this->CalculateOverlapResult(pClusterU, pClusterV, NULL);
     }
 
     for (const Cluster *const pClusterU : clusterVectorU)
     {
         for (const Cluster *const pClusterW : clusterVectorW)
             this->CalculateOverlapResult(pClusterU, NULL, pClusterW);
     }
 
     for (const Cluster *const pClusterV : clusterVectorV)
     {
         for (const Cluster *const pClusterW : clusterVectorW)
             this->CalculateOverlapResult(NULL, pClusterV, pClusterW);
     }
 }

virtual void lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::PreparationStep ( )

protectedvirtualinherited

Perform any preparatory steps required, e.g. caching expensive fit results for clusters.

Reimplemented from lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >.

virtual void lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::PreparationStep ( pandora::ClusterList & clusterList )

protectedvirtualinherited

Preparation step for a specific cluster list.

Parameters

clusterList the cluster list

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

protectedvirtual

Reimplemented from lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >.

Definition at line 634 of file ThreeDTrackFragmentsAlgorithm.cc.

References m_algorithmToolVector, m_maxPointDisplacementSquared, m_minMatchedHits, m_minMatchedSamplingPointFraction, m_minXOverlap, m_minXOverlapFraction, m_nMaxTensorToolRepeats, m_reclusteringAlgorithmName, and lar_content::ThreeDTracksBaseAlgorithm< T >::ReadSettings().

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithm(*this, xmlHandle,
         "ClusterRebuilding", m_reclusteringAlgorithmName));
 
     AlgorithmToolVector algorithmToolVector;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*this, xmlHandle,
         "TrackTools", algorithmToolVector));
 
     for (AlgorithmToolVector::const_iterator iter = algorithmToolVector.begin(), iterEnd = algorithmToolVector.end(); iter != iterEnd; ++iter)
     {
         FragmentTensorTool *const pFragmentTensorTool(dynamic_cast<FragmentTensorTool*>(*iter));
 
         if (NULL == pFragmentTensorTool)
             return STATUS_CODE_INVALID_PARAMETER;
 
         m_algorithmToolVector.push_back(pFragmentTensorTool);
     }
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "NMaxTensorToolRepeats", m_nMaxTensorToolRepeats));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinXOverlap", m_minXOverlap));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinXOverlapFraction", m_minXOverlapFraction));
 
     float maxPointDisplacement = std::sqrt(m_maxPointDisplacementSquared);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MaxPointDisplacement", maxPointDisplacement));
     m_maxPointDisplacementSquared = maxPointDisplacement * maxPointDisplacement;
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinMatchedSamplingPointFraction", m_minMatchedSamplingPointFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinMatchedHits", m_minMatchedHits));
 
     return ThreeDTracksBaseAlgorithm<FragmentOverlapResult>::ReadSettings(xmlHandle);
 }

void lar_content::ThreeDTrackFragmentsAlgorithm::RebuildClusters	(	const pandora::ClusterList &	rebuildList,
		pandora::ClusterList &	newClusters
	)		const

Rebuild clusters after fragmentation.

Parameters

rebuildList	the list of clusters containing hits to be rebuilt
newClusters	the output list of clusters

Definition at line 102 of file ThreeDTrackFragmentsAlgorithm.cc.

References m_reclusteringAlgorithmName.

Referenced by lar_content::ClearTrackFragmentsTool::RebuildClusters().

 {
     const ClusterList *pNewClusterList = NULL;
     std::string oldClusterListName, newClusterListName;
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::InitializeReclustering(*this, TrackList(), rebuildList,
         oldClusterListName));
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::RunClusteringAlgorithm(*this, m_reclusteringAlgorithmName,
         pNewClusterList, newClusterListName));
 
     newClusters.insert(newClusters.end(), pNewClusterList->begin(), pNewClusterList->end());
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndReclustering(*this, newClusterListName));
 }

void lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::RemoveFromSlidingFitCache ( const pandora::Cluster *const pCluster )

protectedinherited

Remova an existing sliding fit result, for the specified cluster, from the algorithm cache.

Parameters

pCluster address of the relevant cluster

virtual void lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::RemoveUnavailableTensorElements ( )

virtualinherited

Update tensor to remove all elements that have been added to pfos and so are unavailable.

virtual void lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::SelectAllInputClusters ( )

protectedvirtualinherited

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

virtual void lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::SelectInputClusters	(	const pandora::ClusterList *const	pInputClusterList,
		pandora::ClusterList &	selectedClusterList
	)		const

virtualinherited

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

Implements lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >.

virtual void lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::SetPfoParameters	(	const ProtoParticle &	protoParticle,
		PandoraContentApi::ParticleFlowObject::Parameters &	pfoParameters
	)		const

virtualinherited

Calculate Pfo properties from proto particle.

Parameters

protoParticle	the input proto particle
pfoParameters	the output pfo parameters

Implements lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >.

static bool lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::SortSplitPositions	(	const pandora::CartesianVector &	lhs,
		const pandora::CartesianVector &	rhs
	)

staticinherited

Sort split position cartesian vectors by increasing x coordinate.

Parameters

lhs	the first cartesian vector
rhs	the second cartesian vector

virtual void lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::TidyUp ( )

protectedvirtualinherited

Tidy member variables in derived class.

Reimplemented from lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >.

void lar_content::ThreeDTrackFragmentsAlgorithm::UpdateForNewCluster ( const pandora::Cluster *const pNewCluster )

virtual

Update to reflect addition of a new cluster to the problem space.

Parameters

pNewCluster address of the new cluster

Reimplemented from lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >.

Definition at line 33 of file ThreeDTrackFragmentsAlgorithm.cc.

References lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::AddToSlidingFitCache(), CalculateOverlapResult(), lar_content::LArClusterHelper::GetClusterHitType(), lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_clusterListU, lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_clusterListV, lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_clusterListW, and lar_content::LArClusterHelper::SortByNHits().

Referenced by lar_content::ClearTrackFragmentsTool::UpdateTensor().

 {
     try
     {
         this->AddToSlidingFitCache(pNewCluster);
     }
     catch (StatusCodeException &statusCodeException)
     {
         if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
             throw statusCodeException;
 
         return;
     }
 
     const HitType hitType(LArClusterHelper::GetClusterHitType(pNewCluster));
 
     if (!((TPC_VIEW_U == hitType) || (TPC_VIEW_V == hitType) || (TPC_VIEW_W == hitType)))
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     ClusterList &clusterList((TPC_VIEW_U == hitType) ? m_clusterListU : (TPC_VIEW_V == hitType) ? m_clusterListV : m_clusterListW);
 
     if (clusterList.end() != std::find(clusterList.begin(), clusterList.end(), pNewCluster))
         throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
 
     clusterList.push_back(pNewCluster);
 
     const ClusterList &clusterList1((TPC_VIEW_U == hitType) ? m_clusterListV : m_clusterListU);
     const ClusterList &clusterList2((TPC_VIEW_W == hitType) ? m_clusterListV : m_clusterListW);
 
     ClusterVector clusterVector1(clusterList1.begin(), clusterList1.end());
     ClusterVector clusterVector2(clusterList2.begin(), clusterList2.end());
     std::sort(clusterVector1.begin(), clusterVector1.end(), LArClusterHelper::SortByNHits);
     std::sort(clusterVector2.begin(), clusterVector2.end(), LArClusterHelper::SortByNHits);
 
     for (const Cluster *const pCluster1 : clusterVector1)
     {
         if (TPC_VIEW_U == hitType)
         {
             this->CalculateOverlapResult(pNewCluster, pCluster1, NULL);
         }
         else if (TPC_VIEW_V == hitType)
         {
             this->CalculateOverlapResult(pCluster1, pNewCluster, NULL);
         }
         else
         {
             this->CalculateOverlapResult(pCluster1, NULL, pNewCluster);
         }
     }
 
     for (const Cluster *const pCluster2 : clusterVector2)
     {
         if (TPC_VIEW_U == hitType)
         {
             this->CalculateOverlapResult(pNewCluster, NULL, pCluster2);
         }
         else if (TPC_VIEW_V == hitType)
         {
             this->CalculateOverlapResult(NULL, pNewCluster, pCluster2);
         }
         else
         {
             this->CalculateOverlapResult(NULL, pCluster2, pNewCluster);
         }
     }
 }

virtual void lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::UpdateUponDeletion ( const pandora::Cluster *const pDeletedCluster )

virtualinherited

Update to reflect cluster deletion.

Parameters

pDeletedCluster address of the deleted cluster

Reimplemented from lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >.

Member Data Documentation

TensorToolVector lar_content::ThreeDTrackFragmentsAlgorithm::m_algorithmToolVector

protected

The algorithm tool list.

Definition at line 144 of file ThreeDTrackFragmentsAlgorithm.h.

Referenced by ExamineTensor(), and ReadSettings().

pandora::ClusterList lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_clusterListU

protectedinherited

The selected modified cluster list U.

Definition at line 196 of file ThreeDBaseAlgorithm.h.

Referenced by PerformMainLoop(), and UpdateForNewCluster().

pandora::ClusterList lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_clusterListV

protectedinherited

The selected modified cluster list V.

Definition at line 197 of file ThreeDBaseAlgorithm.h.

Referenced by PerformMainLoop(), and UpdateForNewCluster().

pandora::ClusterList lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_clusterListW

protectedinherited

The selected modified cluster list W.

Definition at line 198 of file ThreeDBaseAlgorithm.h.

Referenced by PerformMainLoop(), and UpdateForNewCluster().

float lar_content::ThreeDTrackFragmentsAlgorithm::m_maxPointDisplacementSquared

protected

maximum allowed distance (squared) between projected points and associated hits

Definition at line 150 of file ThreeDTrackFragmentsAlgorithm.h.

Referenced by GetFragmentOverlapResult(), GetMatchedHits(), and ReadSettings().

unsigned int lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::m_minClusterCaloHits

protectedinherited

The min number of hits in base cluster selection method.

Definition at line 121 of file ThreeDTracksBaseAlgorithm.h.

float lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::m_minClusterLengthSquared

protectedinherited

The min length (squared) in base cluster selection method.

Definition at line 122 of file ThreeDTracksBaseAlgorithm.h.

unsigned int lar_content::ThreeDTrackFragmentsAlgorithm::m_minMatchedHits

protected

minimum number of matched calo hits

Definition at line 152 of file ThreeDTrackFragmentsAlgorithm.h.

Referenced by CheckOverlapResult(), and ReadSettings().

float lar_content::ThreeDTrackFragmentsAlgorithm::m_minMatchedSamplingPointFraction

protected

minimum fraction of matched sampling points

Definition at line 151 of file ThreeDTrackFragmentsAlgorithm.h.

Referenced by CheckOverlapResult(), and ReadSettings().

float lar_content::ThreeDTrackFragmentsAlgorithm::m_minXOverlap

protected

requirement on minimum X overlap for associated clusters

Definition at line 148 of file ThreeDTrackFragmentsAlgorithm.h.

Referenced by GetProjectedPositions(), and ReadSettings().

float lar_content::ThreeDTrackFragmentsAlgorithm::m_minXOverlapFraction

protected

requirement on minimum X overlap fraction for associated clusters

Definition at line 149 of file ThreeDTrackFragmentsAlgorithm.h.

Referenced by GetProjectedPositions(), and ReadSettings().

unsigned int lar_content::ThreeDTrackFragmentsAlgorithm::m_nMaxTensorToolRepeats

protected

The maximum number of repeat loops over tensor tools.

Definition at line 146 of file ThreeDTrackFragmentsAlgorithm.h.

Referenced by ExamineTensor(), and ReadSettings().

TensorType lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_overlapTensor

protectedinherited

The overlap tensor.

Definition at line 200 of file ThreeDBaseAlgorithm.h.

Referenced by ExamineTensor(), and PerformMainLoop().

const pandora::ClusterList* lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_pInputClusterListU

protectedinherited

Address of the input cluster list U.

Definition at line 192 of file ThreeDBaseAlgorithm.h.

const pandora::ClusterList* lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_pInputClusterListV

protectedinherited

Address of the input cluster list V.

Definition at line 193 of file ThreeDBaseAlgorithm.h.

const pandora::ClusterList* lar_content::ThreeDBaseAlgorithm< FragmentOverlapResult >::m_pInputClusterListW

protectedinherited

Address of the input cluster list W.

Definition at line 194 of file ThreeDBaseAlgorithm.h.

std::string lar_content::ThreeDTrackFragmentsAlgorithm::m_reclusteringAlgorithmName

protected

Name of daughter algorithm to use for cluster re-building.

Definition at line 141 of file ThreeDTrackFragmentsAlgorithm.h.

Referenced by ReadSettings(), and RebuildClusters().

TwoDSlidingFitResultMap lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::m_slidingFitResultMap

protectedinherited

The sliding fit result map.

Definition at line 119 of file ThreeDTracksBaseAlgorithm.h.

unsigned int lar_content::ThreeDTracksBaseAlgorithm< FragmentOverlapResult >::m_slidingFitWindow

protectedinherited

The layer window for the sliding linear fits.

Definition at line 118 of file ThreeDTracksBaseAlgorithm.h.

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

/cvmfs/larsoft.opensciencegrid.org/products/larpandoracontent/v03_14_03/source/larpandoracontent/LArThreeDReco/LArTrackFragments/ThreeDTrackFragmentsAlgorithm.h
/cvmfs/larsoft.opensciencegrid.org/products/larpandoracontent/v03_14_03/source/larpandoracontent/LArThreeDReco/LArTrackFragments/ThreeDTrackFragmentsAlgorithm.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation