TrackRefinementBaseAlgorithm class. More...

#include <TrackRefinementBaseAlgorithm.h>

Inheritance diagram for lar_content::TrackRefinementBaseAlgorithm:

Classes
class	SortByDistanceAlongLine
	SortByDistanceAlongLine class. More...

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

template<typename T >
void	InitialiseContainers (const ClusterList *pClusterList, const T sortFunction, ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const

template<typename T >
void	UpdateContainers (const ClusterList &clustersToAdd, const ClusterList &clustersToDelete, const T sortFunction, ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const

Protected Types
typedef std::pair < TwoDSlidingFitResultMap , TwoDSlidingFitResultMap >	SlidingFitResultMapPair

typedef std::unordered_map < const pandora::Cluster *, pandora::CaloHitList >	ClusterToCaloHitListMap

Protected Member Functions
virtual pandora::StatusCode	Run ()=0

virtual pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)=0

template<typename T >
void	InitialiseContainers (const pandora::ClusterList *pClusterList, const T sortFunction, pandora::ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const
	Fill the cluster vector and sliding fit maps with clusters that are determined to be track-like. More...

bool	GetClusterMergingCoordinates (const TwoDSlidingFitResult &clusterMicroFitResult, const TwoDSlidingFitResult &clusterMacroFitResult, const TwoDSlidingFitResult &associatedMacroFitResult, const bool isEndUpstream, pandora::CartesianVector &clusterMergePosition, pandora::CartesianVector &clusterMergeDirection) const
	Get the merging coordinate and direction for an input cluster with respect to an associated cluster. More...

void	GetHitsInBoundingBox (const pandora::CartesianVector &firstCorner, const pandora::CartesianVector &secondCorner, const pandora::ClusterList *const pClusterList, ClusterToCaloHitListMap &clusterToCaloHitListMap, const pandora::ClusterList &unavailableProtectedClusters=pandora::ClusterList(), const float distanceToLine=-1.f) const
	Find the unprotected hits that are contained within a defined box with the option to apply a cut on the distance to the connecting line. More...

bool	IsInBoundingBox (const float minX, const float maxX, const float minZ, const float maxZ, const pandora::CartesianVector &hitPosition) const
	check whether a hit is contained within a defined square region More...

bool	IsCloseToLine (const pandora::CartesianVector &hitPosition, const pandora::CartesianVector &lineStart, const pandora::CartesianVector &lineDirection, const float distanceToLine) const
	Check whether a hit is close to a line. More...

bool	AreExtrapolatedHitsGood (const ClusterToCaloHitListMap &clusterToCaloHitListMap, ClusterAssociation &clusterAssociation) const
	Perform topological checks on the collected hits to ensure no gaps are present. More...

virtual bool	AreExtrapolatedHitsNearBoundaries (const pandora::CaloHitVector &extrapolatedHitVector, ClusterAssociation &clusterAssociation) const =0
	Check the separation of the extremal extrapolated hits with the expected endpoints or, in the case of no hits, the clusterMergePoint themselves. More...

bool	IsNearBoundary (const pandora::CaloHit *const pCaloHit, const pandora::CartesianVector &boundaryPosition2D, const float boundaryTolerance) const
	Check whether a hit is close to a boundary point. More...

bool	IsTrackContinuous (const ClusterAssociation &clusterAssociation, const pandora::CaloHitVector &extrapolatedCaloHitVector) const
	Check whether the extrapolatedCaloHitVector contains a continuous line of hits between the cluster merge points. More...

void	GetTrackSegmentBoundaries (const ClusterAssociation &clusterAssociation, pandora::CartesianPointVector &trackSegmentBoundaries) const
	Obtain the segment boundaries of the connecting line to test whether extrapolated hits are continuous. More...

void	RepositionIfInGap (const pandora::CartesianVector &mergeDirection, pandora::CartesianVector &trackPoint) const
	Move an input position to the higher line gap edge if it lies within a gap. More...

float	DistanceInGap (const pandora::CartesianVector &upstreamPoint, const pandora::CartesianVector &downstreamPoint, const pandora::CartesianVector &connectingLine, pandora::DetectorGapList &consideredGaps) const
	Calculate the track length between two points that lies in gaps. More...

bool	IsInLineSegment (const pandora::CartesianVector &lowerBoundary, const pandora::CartesianVector &upperBoundary, const pandora::CartesianVector &point) const
	Whether a position falls within a specified segment of the cluster connecting line. More...

const pandora::Cluster *	RemoveOffAxisHitsFromTrack (const pandora::Cluster *const pCluster, const pandora::CartesianVector &splitPosition, const bool isEndUpstream, const ClusterToCaloHitListMap &clusterToCaloHitListMap, pandora::ClusterList &remnantClusterList, TwoDSlidingFitResultMap &microSlidingFitResultMap, TwoDSlidingFitResultMap &macroSlidingFitResultMap) const
	Remove any hits in the upstream/downstream cluster that lie off of the main track axis (i.e. clustering errors) More...

void	AddHitsToMainTrack (const pandora::Cluster const pMainTrackCluster, const pandora::Cluster const pShowerTrackCluster, const pandora::CaloHitList &caloHitsToMerge, const ClusterAssociation &clusterAssociation, pandora::ClusterList &remnantClusterList) const
	Remove the hits from a shower cluster that belong to the main track and add them into the main track cluster. More...

void	ProcessRemnantClusters (const pandora::ClusterList &remnantClusterList, const pandora::Cluster const pMainTrackCluster, const pandora::ClusterList const pClusterList, pandora::ClusterList &createdClusters) const
	Process the remnant clusters separating those that stradle the main track. More...

bool	AddToNearestCluster (const pandora::Cluster const pClusterToMerge, const pandora::Cluster const pMainTrackCluster, const pandora::ClusterList *const pClusterList) const
	Add a cluster to the nearest cluster satisfying separation distance thresholds. More...

bool	IsClusterRemnantDisconnected (const pandora::Cluster *const pRemnantCluster) const
	Whether a remnant cluster is considered to be disconnected and therefore should undergo further fragmentation. More...

void	FragmentRemnantCluster (const pandora::Cluster *const pRemnantCluster, pandora::ClusterList &fragmentedClusterList) const
	Fragment a cluster using simple hit separation logic. More...

template<typename T >
void	UpdateContainers (const pandora::ClusterList &clustersToAdd, const pandora::ClusterList &clustersToDelete, const T sortFunction, pandora::ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const
	Remove deleted clusters from the cluster vector and sliding fit maps and add in created clusters that are determined to be track-like. More...

void	RemoveClusterFromContainers (const pandora::Cluster *const pClustertoRemove, pandora::ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const
	Remove a cluster from the cluster vector and sliding fit maps. More...

Protected Attributes
float	m_minClusterLength
	The minimum length of a considered cluster. More...

unsigned int	m_microSlidingFitWindow
	The sliding fit window used in the fits contained within the microSlidingFitResultMap. More...

unsigned int	m_macroSlidingFitWindow
	The sliding fit window used in the fits contained within the macroSlidingFitResultMap. More...

float	m_stableRegionClusterFraction
	The threshold fraction of fit contributing layers which defines the stable region. More...

float	m_mergePointMinCosAngleDeviation
	The threshold cos opening angle between the cluster local gradient and the associated cluster global gradient used to determine merge points. More...

float	m_minHitFractionForHitRemoval
	The threshold fraction of hits to be removed from the cluster for hit removal to proceed. More...

float	m_maxDistanceFromMainTrack
	The threshold distance for a hit to be added to the main track. More...

float	m_maxHitDistanceFromCluster
	The threshold separation between a hit and cluster for the hit to be merged into the cluster. More...

float	m_maxHitSeparationForConnectedCluster
	The maximum separation between two adjacent (in z) hits in a connected cluster. More...

unsigned int	m_maxTrackGaps
	The maximum number of graps allowed in the extrapolated hit vector. More...

float	m_lineSegmentLength
	The length of a track gap. More...

bool	m_hitWidthMode
	Whether to consider the width of hits. More...

Detailed Description

TrackRefinementBaseAlgorithm class.

Definition at line 21 of file TrackRefinementBaseAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, pandora::CaloHitList> lar_content::TrackRefinementBaseAlgorithm::ClusterToCaloHitListMap

protected

Definition at line 31 of file TrackRefinementBaseAlgorithm.h.

typedef std::pair<TwoDSlidingFitResultMap *, TwoDSlidingFitResultMap *> lar_content::TrackRefinementBaseAlgorithm::SlidingFitResultMapPair

protected

Definition at line 30 of file TrackRefinementBaseAlgorithm.h.

Constructor & Destructor Documentation

lar_content::TrackRefinementBaseAlgorithm::TrackRefinementBaseAlgorithm ( )

Default constructor.

Definition at line 21 of file TrackRefinementBaseAlgorithm.cc.

                                                            :
     m_minClusterLength(15.f),
     m_microSlidingFitWindow(20),
     m_macroSlidingFitWindow(1000),
     m_stableRegionClusterFraction(0.05f),
     m_mergePointMinCosAngleDeviation(0.999f),
     m_minHitFractionForHitRemoval(0.05f),
     m_maxDistanceFromMainTrack(0.75f),
     m_maxHitDistanceFromCluster(4.f),
     m_maxHitSeparationForConnectedCluster(4.f),
     m_maxTrackGaps(3),
     m_lineSegmentLength(3.f),
     m_hitWidthMode(false)
 {
 }

Member Function Documentation

void lar_content::TrackRefinementBaseAlgorithm::AddHitsToMainTrack	(	const pandora::Cluster *const	pMainTrackCluster,
		const pandora::Cluster *const	pShowerTrackCluster,
		const pandora::CaloHitList &	caloHitsToMerge,
		const ClusterAssociation &	clusterAssociation,
		pandora::ClusterList &	remnantClusterList
	)		const

protected

Remove the hits from a shower cluster that belong to the main track and add them into the main track cluster.

Parameters

pMainTrackCluster	the main track cluster
pShowerCluster	the input shower cluster
caloHitsToMerge	the list of calo hits to remove from the shower cluster
clusterAssociation	the clusterAssociation
remnantClusterList	the input list to store the remnant clusters

Definition at line 573 of file TrackRefinementBaseAlgorithm.cc.

 {
     // To ignore crossing CR muon or test beam tracks
     if (((static_cast<float>(caloHitsToMerge.size()) / static_cast<float>(pShowerCluster->GetNCaloHits())) < m_minHitFractionForHitRemoval) &&
         (LArClusterHelper::GetLengthSquared(pShowerCluster) > m_minClusterLength))
         return;
 
     if (pShowerCluster->GetNCaloHits() == caloHitsToMerge.size())
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*this, pMainTrackCluster, pShowerCluster));
         return;
     }
 
     // Fragmentation initialisation
     std::string originalListName, fragmentListName;
     const ClusterList originalClusterList(1, pShowerCluster);
     PANDORA_THROW_RESULT_IF(
         STATUS_CODE_SUCCESS, !=, PandoraContentApi::InitializeFragmentation(*this, originalClusterList, originalListName, fragmentListName));
 
     const Cluster *pAboveCluster(nullptr), *pBelowCluster(nullptr);
 
     const bool isVertical(std::fabs(clusterAssociation.GetConnectingLineDirection().GetX()) < std::numeric_limits<float>::epsilon());
     const float connectingLineGradient(
         isVertical ? 0.f : clusterAssociation.GetConnectingLineDirection().GetZ() / clusterAssociation.GetConnectingLineDirection().GetX());
     const float connectingLineIntercept(isVertical ? clusterAssociation.GetUpstreamMergePoint().GetX()
                                                    : clusterAssociation.GetUpstreamMergePoint().GetZ() -
                                                          (connectingLineGradient * clusterAssociation.GetUpstreamMergePoint().GetX()));
 
     const OrderedCaloHitList orderedCaloHitList(pShowerCluster->GetOrderedCaloHitList());
     for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
     {
         for (const CaloHit *const pCaloHit : *mapEntry.second)
         {
             const bool isAnExtrapolatedHit(std::find(caloHitsToMerge.begin(), caloHitsToMerge.end(), pCaloHit) != caloHitsToMerge.end());
             if (isAnExtrapolatedHit)
             {
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::RemoveFromCluster(*this, pShowerCluster, pCaloHit));
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pMainTrackCluster, pCaloHit));
             }
             else
             {
                 const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
                 const bool isAbove(((connectingLineGradient * hitPosition.GetX()) + connectingLineIntercept) <
                                    (isVertical ? hitPosition.GetX() : hitPosition.GetZ()));
                 const Cluster *&pClusterToModify(isAbove ? pAboveCluster : pBelowCluster);
 
                 if (pClusterToModify)
                 {
                     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pClusterToModify, pCaloHit));
                 }
                 else
                 {
                     PandoraContentApi::Cluster::Parameters parameters;
                     parameters.m_caloHitList.push_back(pCaloHit);
                     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pClusterToModify));
 
                     remnantClusterList.push_back(pClusterToModify);
                 }
             }
         }
     }
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, fragmentListName, originalListName));
 }

bool lar_content::TrackRefinementBaseAlgorithm::AddToNearestCluster	(	const pandora::Cluster *const	pClusterToMerge,
		const pandora::Cluster *const	pMainTrackCluster,
		const pandora::ClusterList *const	pClusterList
	)		const

protected

Add a cluster to the nearest cluster satisfying separation distance thresholds.

Parameters

pClusterToMerge	the cluster to merge
pMainTrackCluster	the main track cluster
pClusterList	the list of all clusters

Returns: whether cluster was added to a nearby cluster

Definition at line 668 of file TrackRefinementBaseAlgorithm.cc.

 {
     const Cluster *pClosestCluster(nullptr);
     float closestDistance(std::numeric_limits<float>::max());
 
     for (const Cluster *const pCluster : *pClusterList)
     {
         if (pCluster == pClusterToMerge)
             continue;
 
         const float separationDistance(LArClusterHelper::GetClosestDistance(pClusterToMerge, pCluster));
 
         if (separationDistance < closestDistance)
         {
             if ((pCluster == pMainTrackCluster) && (separationDistance > m_maxDistanceFromMainTrack))
                 continue;
 
             pClosestCluster = pCluster;
             closestDistance = separationDistance;
         }
     }
 
     if (closestDistance < m_maxHitDistanceFromCluster)
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*this, pClosestCluster, pClusterToMerge));
         return true;
     }
 
     return false;
 }

bool lar_content::TrackRefinementBaseAlgorithm::AreExtrapolatedHitsGood	(	const ClusterToCaloHitListMap &	clusterToCaloHitListMap,
		ClusterAssociation &	clusterAssociation
	)		const

protected

Perform topological checks on the collected hits to ensure no gaps are present.

Parameters

clusterToCaloHitListMap	the input map [parent cluster -> list of hits which belong to the main track]
clusterAssociation	the clusterAssociation

Returns: whether the checks pass

Definition at line 188 of file TrackRefinementBaseAlgorithm.cc.

 {
     CaloHitVector extrapolatedHitVector;
     for (const auto &entry : clusterToCaloHitListMap)
         extrapolatedHitVector.insert(extrapolatedHitVector.begin(), entry.second.begin(), entry.second.end());
 
     // ATTN: Extrapolated hit checks require extrapolatedHitVector to be ordered from upstream -> downstream merge point
     std::sort(extrapolatedHitVector.begin(), extrapolatedHitVector.end(),
         SortByDistanceAlongLine(clusterAssociation.GetUpstreamMergePoint(), clusterAssociation.GetConnectingLineDirection(), m_hitWidthMode));
 
     if (!this->AreExtrapolatedHitsNearBoundaries(extrapolatedHitVector, clusterAssociation))
         return false;
 
     if (clusterToCaloHitListMap.empty())
         return true;
 
     if (!this->IsTrackContinuous(clusterAssociation, extrapolatedHitVector))
         return false;
 
     return true;
 }

virtual bool lar_content::TrackRefinementBaseAlgorithm::AreExtrapolatedHitsNearBoundaries	(	const pandora::CaloHitVector &	extrapolatedHitVector,
		ClusterAssociation &	clusterAssociation
	)		const

protectedpure virtual

Check the separation of the extremal extrapolated hits with the expected endpoints or, in the case of no hits, the clusterMergePoint themselves.

Parameters

extrapolatedHitVector	the extrapolated hit vector (ordered closest hit to the upstream merge point -> furthest hit)
clusterAssociation	the clusterAssociation

Returns: whether the check passes

Implemented in lar_content::TrackMergeRefinementAlgorithm.

float lar_content::TrackRefinementBaseAlgorithm::DistanceInGap	(	const pandora::CartesianVector &	upstreamPoint,
		const pandora::CartesianVector &	downstreamPoint,
		const pandora::CartesianVector &	connectingLine,
		pandora::DetectorGapList &	consideredGaps
	)		const

protected

Calculate the track length between two points that lies in gaps.

Parameters

upstreamPoint	the upstream point
downstreamPoint	the downstream point
connectingLine	the track direction
consideredGaps	the list of gaps to ignore

Definition at line 385 of file TrackRefinementBaseAlgorithm.cc.

 {
     const CartesianVector &lowerXPoint(upstreamPoint.GetX() < downstreamPoint.GetX() ? upstreamPoint : downstreamPoint);
     const CartesianVector &higherXPoint(upstreamPoint.GetX() < downstreamPoint.GetX() ? downstreamPoint : upstreamPoint);
 
     const float cosAngleToX(std::fabs(connectingLine.GetDotProduct(CartesianVector(1.f, 0.f, 0.f))));
     const float cosAngleToZ(std::fabs(connectingLine.GetDotProduct(CartesianVector(0.f, 0.f, 1.f))));
 
     float distanceInGaps(0.f);
     const DetectorGapList detectorGapList(this->GetPandora().GetGeometry()->GetDetectorGapList());
     for (const DetectorGap *const pDetectorGap : detectorGapList)
     {
         if (std::find(consideredGaps.begin(), consideredGaps.end(), pDetectorGap) != consideredGaps.end())
             continue;
 
         const LineGap *const pLineGap(dynamic_cast<const LineGap *>(pDetectorGap));
 
         if (pLineGap)
         {
             const LineGapType lineGapType(pLineGap->GetLineGapType());
 
             if (lineGapType == TPC_DRIFT_GAP)
             {
                 float xDistanceInGap(0.f);
 
                 if ((pLineGap->GetLineStartX() > lowerXPoint.GetX()) && (pLineGap->GetLineEndX() < higherXPoint.GetX()))
                 {
                     xDistanceInGap = (pLineGap->GetLineEndX() - pLineGap->GetLineStartX());
                 }
                 else if ((pLineGap->GetLineStartX() < lowerXPoint.GetX()) && (pLineGap->GetLineEndX() > lowerXPoint.GetX()))
                 {
                     xDistanceInGap = (pLineGap->GetLineEndX() - lowerXPoint.GetX());
                 }
                 else if ((pLineGap->GetLineStartX() < higherXPoint.GetX()) && (pLineGap->GetLineEndX() > higherXPoint.GetX()))
                 {
                     xDistanceInGap = (higherXPoint.GetX() - pLineGap->GetLineStartX());
                 }
                 else
                 {
                     continue;
                 }
 
                 if (std::fabs(cosAngleToX) < std::numeric_limits<float>::epsilon())
                     throw StatusCodeException(STATUS_CODE_FAILURE);
 
                 distanceInGaps += (xDistanceInGap / cosAngleToX);
 
                 consideredGaps.push_back(pDetectorGap);
             }
 
             if ((lineGapType == TPC_WIRE_GAP_VIEW_U) || (lineGapType == TPC_WIRE_GAP_VIEW_V) || (lineGapType == TPC_WIRE_GAP_VIEW_W))
             {
                 float zDistanceInGap(0.f);
 
                 if ((pLineGap->GetLineStartZ() > upstreamPoint.GetZ()) && (pLineGap->GetLineEndZ() < downstreamPoint.GetZ()))
                 {
                     zDistanceInGap = pLineGap->GetLineEndZ() - pLineGap->GetLineStartZ();
                 }
                 else if ((pLineGap->GetLineStartZ() < upstreamPoint.GetZ()) && (pLineGap->GetLineEndZ() > upstreamPoint.GetZ()))
                 {
                     zDistanceInGap = pLineGap->GetLineEndZ() - upstreamPoint.GetZ();
                 }
                 else if ((pLineGap->GetLineStartZ() < downstreamPoint.GetZ()) && (pLineGap->GetLineEndZ() > downstreamPoint.GetZ()))
                 {
                     zDistanceInGap = downstreamPoint.GetZ() - pLineGap->GetLineStartZ();
                 }
                 else
                 {
                     continue;
                 }
 
                 if (std::fabs(cosAngleToZ) < std::numeric_limits<float>::epsilon())
                     throw StatusCodeException(STATUS_CODE_FAILURE);
 
                 distanceInGaps += (zDistanceInGap / cosAngleToZ);
 
                 consideredGaps.push_back(pDetectorGap);
             }
         }
     }
 
     return distanceInGaps;
 }

void lar_content::TrackRefinementBaseAlgorithm::FragmentRemnantCluster	(	const pandora::Cluster *const	pRemnantCluster,
		pandora::ClusterList &	fragmentedClusterList
	)		const

protected

Fragment a cluster using simple hit separation logic.

Parameters

pRemnantCluster	the input remnant cluster to fragment
fragmentedClusterList	the input list to store the final remnant clusters

Definition at line 731 of file TrackRefinementBaseAlgorithm.cc.

 {
     // Fragmentation initialisation
     std::string originalListName, fragmentListName;
     const ClusterList originalClusterList(1, pRemnantCluster);
     PANDORA_THROW_RESULT_IF(
         STATUS_CODE_SUCCESS, !=, PandoraContentApi::InitializeFragmentation(*this, originalClusterList, originalListName, fragmentListName));
 
     ClusterList createdClusters;
 
     const OrderedCaloHitList &orderedCaloHitList(pRemnantCluster->GetOrderedCaloHitList());
     for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
     {
         for (const CaloHit *const pCaloHit : *mapEntry.second)
         {
             const Cluster *pClosestCluster(nullptr);
 
             if (!createdClusters.empty())
             {
                 float closestDistance(std::numeric_limits<float>::max());
 
                 for (const Cluster *const pCreatedCluster : createdClusters)
                 {
                     const float separationDistance(LArClusterHelper::GetClosestDistance(pCaloHit->GetPositionVector(), pCreatedCluster));
                     if ((separationDistance < closestDistance) && (separationDistance < m_maxHitDistanceFromCluster))
                     {
                         closestDistance = separationDistance;
                         pClosestCluster = pCreatedCluster;
                     }
                 }
             }
 
             if (pClosestCluster)
             {
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pClosestCluster, pCaloHit));
             }
             else
             {
                 PandoraContentApi::Cluster::Parameters parameters;
                 parameters.m_caloHitList.push_back(pCaloHit);
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pClosestCluster));
                 createdClusters.push_back(pClosestCluster);
             }
         }
     }
 
     // End fragmentation
     if (createdClusters.empty())
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, originalListName, fragmentListName));
         fragmentedClusterList.push_back(pRemnantCluster);
     }
     else
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, fragmentListName, originalListName));
         fragmentedClusterList.insert(fragmentedClusterList.begin(), createdClusters.begin(), createdClusters.end());
     }
 }

bool lar_content::TrackRefinementBaseAlgorithm::GetClusterMergingCoordinates	(	const TwoDSlidingFitResult &	clusterMicroFitResult,
		const TwoDSlidingFitResult &	clusterMacroFitResult,
		const TwoDSlidingFitResult &	associatedMacroFitResult,
		const bool	isEndUpstream,
		pandora::CartesianVector &	clusterMergePosition,
		pandora::CartesianVector &	clusterMergeDirection
	)		const

protected

Get the merging coordinate and direction for an input cluster with respect to an associated cluster.

Parameters

clusterMicroFitResult	the local TwoDSlidingFitResult of the cluster
clusterMacroFitResult	the global TwoDSlidingFitResult of the cluster
associatedMacroFitReult	the global TwoDSlidingFitResult of the associated cluster
isEndUpstream	whether the sought cluster merge point is the upstream
clusterMergePosition	the merge position of the cluster
clusterMergeDirection	the merge direction of the cluster

Returns: whether it was possible to find a suitable merge position

Definition at line 69 of file TrackRefinementBaseAlgorithm.cc.

 {
     CartesianVector clusterAverageDirection(0.f, 0.f, 0.f), associatedAverageDirection(0.f, 0.f, 0.f);
     clusterMacroFitResult.GetGlobalDirection(clusterMacroFitResult.GetLayerFitResultMap().begin()->second.GetGradient(), clusterAverageDirection);
     associatedMacroFitResult.GetGlobalDirection(associatedMacroFitResult.GetLayerFitResultMap().begin()->second.GetGradient(), associatedAverageDirection);
 
     const LayerFitResultMap &clusterMicroLayerFitResultMap(clusterMicroFitResult.GetLayerFitResultMap());
     const int startLayer(isEndUpstream ? clusterMicroFitResult.GetMinLayer() : clusterMicroFitResult.GetMaxLayer());
     const int endLayer(isEndUpstream ? clusterMicroFitResult.GetMaxLayer() : clusterMicroFitResult.GetMinLayer());
     const int loopTerminationLayer(endLayer + (isEndUpstream ? 1 : -1));
     const int step(isEndUpstream ? 1 : -1);
 
     // ATTN: Search for stable region for which the local layer gradient agrees well with associated cluster global gradient
     unsigned int gradientStabilityWindow(std::ceil(clusterMicroLayerFitResultMap.size() * m_stableRegionClusterFraction));
     unsigned int goodLayerCount(0);
 
     clusterMicroLayerFitResultMap.at(endLayer);
 
     for (int i = startLayer; i != loopTerminationLayer; i += step)
     {
         const auto microIter(clusterMicroLayerFitResultMap.find(i));
 
         if (microIter == clusterMicroLayerFitResultMap.end())
             continue;
 
         CartesianVector microDirection(0.f, 0.f, 0.f);
         clusterMicroFitResult.GetGlobalDirection(microIter->second.GetGradient(), microDirection);
 
         const float cosDirectionOpeningAngle(microDirection.GetCosOpeningAngle(associatedAverageDirection));
         if (cosDirectionOpeningAngle > m_mergePointMinCosAngleDeviation)
         {
             // ATTN: Set merge point and direction as that at the first layer in the stable region
             if (goodLayerCount == 0)
             {
                 clusterMergeDirection = clusterAverageDirection;
                 PANDORA_THROW_RESULT_IF(
                     STATUS_CODE_SUCCESS, !=, clusterMicroFitResult.GetGlobalFitPosition(microIter->second.GetL(), clusterMergePosition));
             }
 
             ++goodLayerCount;
         }
         else
         {
             goodLayerCount = 0;
         }
 
         if (goodLayerCount > gradientStabilityWindow)
             break;
 
         // ATTN: Abort merging process have not found a stable region
         if (i == endLayer)
             return false;
     }
 
     return true;
 }

void lar_content::TrackRefinementBaseAlgorithm::GetHitsInBoundingBox	(	const pandora::CartesianVector &	firstCorner,
		const pandora::CartesianVector &	secondCorner,
		const pandora::ClusterList *const	pClusterList,
		ClusterToCaloHitListMap &	clusterToCaloHitListMap,
		const pandora::ClusterList &	unavailableProtectedClusters = `pandora::ClusterList()`,
		const float	distanceToLine = `-1.f`
	)		const

protected

Find the unprotected hits that are contained within a defined box with the option to apply a cut on the distance to the connecting line.

Parameters

firstCorner	the position of one corner
secondCorner	the position of the opposite corner
pClusterList	the list of all clusters
clusterToCaloHitListMap	the output map [parent cluster -> list of hits which belong to the main track]
unavailableProtectedClusters	the list of clusters whose hits are protected
distanceToLine	the maximum perpendicular distance of a collected hit from the connecting line

Definition at line 130 of file TrackRefinementBaseAlgorithm.cc.

 {
     const float minX(std::min(firstCorner.GetX(), secondCorner.GetX())), maxX(std::max(firstCorner.GetX(), secondCorner.GetX()));
     const float minZ(std::min(firstCorner.GetZ(), secondCorner.GetZ())), maxZ(std::max(firstCorner.GetZ(), secondCorner.GetZ()));
 
     CartesianVector connectingLineDirection(firstCorner - secondCorner);
     connectingLineDirection = connectingLineDirection.GetUnitVector();
 
     for (const Cluster *const pCluster : *pClusterList)
     {
         if (std::find(unavailableProtectedClusters.begin(), unavailableProtectedClusters.end(), pCluster) != unavailableProtectedClusters.end())
             continue;
 
         const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());
         for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
         {
             for (const CaloHit *const pCaloHit : *mapEntry.second)
             {
                 CartesianVector hitPosition(m_hitWidthMode ? LArHitWidthHelper::GetClosestPointToLine2D(firstCorner, connectingLineDirection, pCaloHit)
                                                            : pCaloHit->GetPositionVector());
 
                 if (!this->IsInBoundingBox(minX, maxX, minZ, maxZ, hitPosition))
                     continue;
 
                 if (distanceToLine > 0.f)
                 {
                     if (!this->IsCloseToLine(hitPosition, firstCorner, connectingLineDirection, distanceToLine))
                         continue;
                 }
 
                 clusterToCaloHitListMap[pCluster].push_back(pCaloHit);
             }
         }
     }
 }

void lar_content::TrackRefinementBaseAlgorithm::GetTrackSegmentBoundaries	(	const ClusterAssociation &	clusterAssociation,
		pandora::CartesianPointVector &	trackSegmentBoundaries
	)		const

protected

Obtain the segment boundaries of the connecting line to test whether extrapolated hits are continuous.

Parameters

clusterAssociation	the clusterAssociation
trackSegmentBoundaries	the output vector of segment boundaries

Definition at line 275 of file TrackRefinementBaseAlgorithm.cc.

 {
     if (m_lineSegmentLength < std::numeric_limits<float>::epsilon())
     {
         std::cout << "TrackInEMShowerAlgorithm: Line segment length must be positive and nonzero" << std::endl;
         throw STATUS_CODE_INVALID_PARAMETER;
     }
 
     const CartesianVector &trackDirection(clusterAssociation.GetConnectingLineDirection());
     float trackLength((clusterAssociation.GetUpstreamMergePoint() - clusterAssociation.GetDownstreamMergePoint()).GetMagnitude());
 
     // ATTN: Consider the existence of gaps where no hits will be found
     DetectorGapList consideredGaps;
     trackLength -= this->DistanceInGap(
         clusterAssociation.GetUpstreamMergePoint(), clusterAssociation.GetDownstreamMergePoint(), trackDirection, consideredGaps);
     consideredGaps.clear();
 
     const int fullSegments(std::floor(trackLength / m_lineSegmentLength));
 
     if (fullSegments == 0)
     {
         trackSegmentBoundaries = {clusterAssociation.GetUpstreamMergePoint(), clusterAssociation.GetDownstreamMergePoint()};
         return;
     }
 
     // ATTN: To handle final segment merge track remainder with preceding segment and if track remainder was more than half of the segment length split into two
     const float lengthOfTrackRemainder(trackLength - (fullSegments * m_lineSegmentLength));
     const bool splitFinalSegment(lengthOfTrackRemainder > m_lineSegmentLength * 0.5f);
     const int numberOfBoundaries(fullSegments + (splitFinalSegment ? 2 : 1));
 
     CartesianVector segmentUpstreamBoundary(clusterAssociation.GetUpstreamMergePoint()), segmentDownstreamBoundary(segmentUpstreamBoundary);
     this->RepositionIfInGap(trackDirection, segmentUpstreamBoundary);
     trackSegmentBoundaries.push_back(segmentUpstreamBoundary);
 
     for (int i = 1; i < numberOfBoundaries; ++i)
     {
         if (i < fullSegments)
         {
             segmentDownstreamBoundary += trackDirection * m_lineSegmentLength;
         }
         else
         {
             if (splitFinalSegment)
             {
                 segmentDownstreamBoundary += trackDirection * (m_lineSegmentLength + lengthOfTrackRemainder) * 0.5f;
             }
             else
             {
                 segmentDownstreamBoundary += trackDirection * (m_lineSegmentLength + lengthOfTrackRemainder);
             }
         }
 
         float distanceInGap(this->DistanceInGap(segmentUpstreamBoundary, segmentDownstreamBoundary, trackDirection, consideredGaps));
         while (distanceInGap > std::numeric_limits<float>::epsilon())
         {
             this->RepositionIfInGap(trackDirection, segmentDownstreamBoundary);
             segmentDownstreamBoundary += trackDirection * distanceInGap;
             distanceInGap = this->DistanceInGap(segmentUpstreamBoundary, segmentDownstreamBoundary, trackDirection, consideredGaps);
         }
 
         trackSegmentBoundaries.push_back(segmentDownstreamBoundary);
     }
 }

template<typename T >

void lar_content::TrackRefinementBaseAlgorithm::InitialiseContainers	(	const ClusterList *	pClusterList,
		const T	sortFunction,
		ClusterVector &	clusterVector,
		SlidingFitResultMapPair &	slidingFitResultMapPair
	)		const

Definition at line 40 of file TrackRefinementBaseAlgorithm.cc.

 {
     const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
 
     for (const Cluster *const pCluster : *pClusterList)
     {
         if (LArClusterHelper::GetLengthSquared(pCluster) < m_minClusterLength * m_minClusterLength)
             continue;
 
         try
         {
             const TwoDSlidingFitResult microSlidingFitResult(pCluster, m_microSlidingFitWindow, slidingFitPitch);
             const TwoDSlidingFitResult macroSlidingFitResult(pCluster, m_macroSlidingFitWindow, slidingFitPitch);
 
             slidingFitResultMapPair.first->insert(TwoDSlidingFitResultMap::value_type(pCluster, microSlidingFitResult));
             slidingFitResultMapPair.second->insert(TwoDSlidingFitResultMap::value_type(pCluster, macroSlidingFitResult));
             clusterVector.push_back(pCluster);
         }
         catch (const StatusCodeException &)
         {
         }
     }
 
     std::sort(clusterVector.begin(), clusterVector.end(), sortFunction);
 }

template<typename T >

void lar_content::TrackRefinementBaseAlgorithm::InitialiseContainers	(	const pandora::ClusterList *	pClusterList,
		const T	sortFunction,
		pandora::ClusterVector &	clusterVector,
		SlidingFitResultMapPair &	slidingFitResultMapPair
	)		const

protected

Fill the cluster vector and sliding fit maps with clusters that are determined to be track-like.

Parameters

pClusterList	the list of input clusters
sortFunction	the sort class or function used to sort the clusterVector
clusterVector	the input vector to store clusters considered within the algorithm
slidingFitResultMapPair	the {micro, macro} pair of [cluster -> TwoDSlidingFitResult] maps

bool lar_content::TrackRefinementBaseAlgorithm::IsCloseToLine	(	const pandora::CartesianVector &	hitPosition,
		const pandora::CartesianVector &	lineStart,
		const pandora::CartesianVector &	lineDirection,
		const float	distanceToLine
	)		const

protected

Check whether a hit is close to a line.

Parameters

hitPosition	the position of the hit
lineStart	the start point of the line (can actually be any point on the line)
lineDirection	the unit vector of the line direction
distanceToLine	the definition of 'close'

Returns: whether the hit is close to the line

Definition at line 178 of file TrackRefinementBaseAlgorithm.cc.

 {
     const float transverseDistanceFromLine(lineDirection.GetCrossProduct(hitPosition - lineStart).GetMagnitude());
 
     return (transverseDistanceFromLine < distanceToLine);
 }

bool lar_content::TrackRefinementBaseAlgorithm::IsClusterRemnantDisconnected ( const pandora::Cluster *const pRemnantCluster ) const

protected

Whether a remnant cluster is considered to be disconnected and therefore should undergo further fragmentation.

Parameters

pRemnantCluster the input remnant cluster

Returns: whether the remnant cluster is disconnected

Definition at line 702 of file TrackRefinementBaseAlgorithm.cc.

 {
     if (pRemnantCluster->GetNCaloHits() == 1)
         return false;
 
     const OrderedCaloHitList &orderedCaloHitList(pRemnantCluster->GetOrderedCaloHitList());
     const CaloHit *pPreviousCaloHit(orderedCaloHitList.begin()->second->front());
 
     for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
     {
         for (const CaloHit *const pCaloHit : *mapEntry.second)
         {
             if (pCaloHit == pPreviousCaloHit)
                 continue;
 
             const float separationDistanceSquared(pCaloHit->GetPositionVector().GetDistanceSquared(pPreviousCaloHit->GetPositionVector()));
 
             if (separationDistanceSquared > (m_maxHitSeparationForConnectedCluster * m_maxHitSeparationForConnectedCluster))
                 return true;
 
             pPreviousCaloHit = pCaloHit;
         }
     }
 
     return false;
 }

bool lar_content::TrackRefinementBaseAlgorithm::IsInBoundingBox	(	const float	minX,
		const float	maxX,
		const float	minZ,
		const float	maxZ,
		const pandora::CartesianVector &	hitPosition
	)		const

protected

check whether a hit is contained within a defined square region

Parameters

minX	the minimum x coordinate of the square region
maxX	the maximum x coordinate of the square region
minZ	the minimum z coordinate of the square region
maxZ	the maximum z coordinate of the square region
hitPosition	the position of the hit

Returns: whether the hit is contained within the square region

Definition at line 170 of file TrackRefinementBaseAlgorithm.cc.

 {
     return !((hitPosition.GetX() < minX) || (hitPosition.GetX() > maxX) || (hitPosition.GetZ() < minZ) || (hitPosition.GetZ() > maxZ));
 }

bool lar_content::TrackRefinementBaseAlgorithm::IsInLineSegment	(	const pandora::CartesianVector &	lowerBoundary,
		const pandora::CartesianVector &	upperBoundary,
		const pandora::CartesianVector &	point
	)		const

protected

Whether a position falls within a specified segment of the cluster connecting line.

Parameters

lowerBoundary	the lower boundary of the segment
upperBoundary	the upper boundary of the segment
point	the position

Returns: whether the position falls within segment

Definition at line 472 of file TrackRefinementBaseAlgorithm.cc.

 {
     const float segmentBoundaryGradient = (-1.f) * (upperBoundary.GetX() - lowerBoundary.GetX()) / (upperBoundary.GetZ() - lowerBoundary.GetZ());
     const float xPointOnUpperLine((point.GetZ() - upperBoundary.GetZ()) / segmentBoundaryGradient + upperBoundary.GetX());
     const float xPointOnLowerLine((point.GetZ() - lowerBoundary.GetZ()) / segmentBoundaryGradient + lowerBoundary.GetX());
 
     if (std::fabs(xPointOnUpperLine - point.GetX()) < std::numeric_limits<float>::epsilon())
         return true;
 
     if (std::fabs(xPointOnLowerLine - point.GetX()) < std::numeric_limits<float>::epsilon())
         return true;
 
     if ((point.GetX() > xPointOnUpperLine) && (point.GetX() > xPointOnLowerLine))
         return false;
 
     if ((point.GetX() < xPointOnUpperLine) && (point.GetX() < xPointOnLowerLine))
         return false;
 
     return true;
 }

bool lar_content::TrackRefinementBaseAlgorithm::IsNearBoundary	(	const pandora::CaloHit *const	pCaloHit,
		const pandora::CartesianVector &	boundaryPosition2D,
		const float	boundaryTolerance
	)		const

protected

Check whether a hit is close to a boundary point.

Parameters

pCaloHit	the input calo hit
boundaryPosition2D	the position of the 2D boundary point
boundaryTolerance	the definition of close

Returns: whether the check passes

Definition at line 212 of file TrackRefinementBaseAlgorithm.cc.

 {
     const float distanceToBoundary(LArHitWidthHelper::GetClosestDistanceToPoint2D(pCaloHit, boundaryPosition2D));
 
     return (distanceToBoundary < boundaryTolerance);
 }

bool lar_content::TrackRefinementBaseAlgorithm::IsTrackContinuous	(	const ClusterAssociation &	clusterAssociation,
		const pandora::CaloHitVector &	extrapolatedCaloHitVector
	)		const

protected

Check whether the extrapolatedCaloHitVector contains a continuous line of hits between the cluster merge points.

Parameters

clusterAssociation	the clusterAssociation
extrapolatedCaloHitVector	the vector of extrapolated calo hits

Returns: whether the calo hits are continuous

Definition at line 221 of file TrackRefinementBaseAlgorithm.cc.

 {
     CartesianPointVector trackSegmentBoundaries;
     this->GetTrackSegmentBoundaries(clusterAssociation, trackSegmentBoundaries);
 
     if (trackSegmentBoundaries.size() < 2)
     {
         std::cout << "TrackInEMShowerAlgorithm: Less than two track segment boundaries" << std::endl;
         throw STATUS_CODE_NOT_ALLOWED;
     }
 
     unsigned int segmentsWithoutHits(0);
     CaloHitVector::const_iterator caloHitIter(extrapolatedCaloHitVector.begin());
     CartesianVector hitPosition(m_hitWidthMode ? LArHitWidthHelper::GetClosestPointToLine2D(clusterAssociation.GetUpstreamMergePoint(),
                                                      clusterAssociation.GetConnectingLineDirection(), *caloHitIter)
                                                : (*caloHitIter)->GetPositionVector());
 
     for (unsigned int i = 0; i < (trackSegmentBoundaries.size() - 1); ++i)
     {
         if (caloHitIter == extrapolatedCaloHitVector.end())
         {
             ++segmentsWithoutHits;
 
             if (segmentsWithoutHits > m_maxTrackGaps)
                 return false;
 
             continue;
         }
 
         unsigned int hitsInSegment(0);
         while (this->IsInLineSegment(trackSegmentBoundaries.at(i), trackSegmentBoundaries.at(i + 1), hitPosition))
         {
             ++hitsInSegment;
             ++caloHitIter;
 
             if (caloHitIter == extrapolatedCaloHitVector.end())
                 break;
 
             hitPosition = m_hitWidthMode ? LArHitWidthHelper::GetClosestPointToLine2D(clusterAssociation.GetUpstreamMergePoint(),
                                                clusterAssociation.GetConnectingLineDirection(), *caloHitIter)
                                          : (*caloHitIter)->GetPositionVector();
         }
 
         segmentsWithoutHits = hitsInSegment ? 0 : segmentsWithoutHits + 1;
 
         if (segmentsWithoutHits > m_maxTrackGaps)
             return false;
     }
 
     return true;
 }

void lar_content::TrackRefinementBaseAlgorithm::ProcessRemnantClusters	(	const pandora::ClusterList &	remnantClusterList,
		const pandora::Cluster *const	pMainTrackCluster,
		const pandora::ClusterList *const	pClusterList,
		pandora::ClusterList &	createdClusters
	)		const

protected

Process the remnant clusters separating those that stradle the main track.

Parameters

remnantClusterList	the list of remnant clusters to process
pMainTrackCluster	the main track cluster
pClusterList	the list of all clusters
createdClusters	the input list to store the final remnant clusters

Definition at line 641 of file TrackRefinementBaseAlgorithm.cc.

 {
     ClusterList fragmentedClusters;
     for (const Cluster *const pRemnantCluster : remnantClusterList)
     {
         if (this->IsClusterRemnantDisconnected(pRemnantCluster))
         {
             this->FragmentRemnantCluster(pRemnantCluster, fragmentedClusters);
         }
         else
         {
             fragmentedClusters.push_back(pRemnantCluster);
         }
     }
 
     for (const Cluster *const pFragmentedCluster : fragmentedClusters)
     {
         if ((pFragmentedCluster->GetNCaloHits() == 1) && (this->AddToNearestCluster(pFragmentedCluster, pMainTrackCluster, pClusterList)))
             continue;
 
         createdClusters.push_back(pFragmentedCluster);
     }
 }

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

protectedpure virtual

Implemented in lar_content::TrackMergeRefinementAlgorithm.

Definition at line 823 of file TrackRefinementBaseAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterLength", m_minClusterLength));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MicroSlidingFitWindow", m_microSlidingFitWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MacroSlidingFitWindow", m_macroSlidingFitWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "StableRegionClusterFraction", m_stableRegionClusterFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MergePointMinCosAngleDeviation", m_mergePointMinCosAngleDeviation));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinHitFractionForHitRemoval", m_minHitFractionForHitRemoval));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxDistanceFromMainTrack", m_maxDistanceFromMainTrack));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxHitDistanceFromCluster", m_maxHitDistanceFromCluster));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxHitSeparationForConnectedCluster", m_maxHitSeparationForConnectedCluster));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxTrackGaps", m_maxTrackGaps));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "LineSegmentLength", m_lineSegmentLength));
 
     if (m_lineSegmentLength < std::numeric_limits<float>::epsilon())
     {
         std::cout << "TrackInEMShowerAlgorithm: Line segment length must be positive and nonzero" << std::endl;
         throw STATUS_CODE_INVALID_PARAMETER;
     }
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "HitWidthMode", m_hitWidthMode));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::TrackRefinementBaseAlgorithm::RemoveClusterFromContainers	(	const pandora::Cluster *const	pClustertoRemove,
		pandora::ClusterVector &	clusterVector,
		SlidingFitResultMapPair &	slidingFitResultMapPair
	)		const

protected

Remove a cluster from the cluster vector and sliding fit maps.

Parameters

pClustertoRemove	the clusters to remove from the containers
clusterVector	the vector to store clusters considered within the algorithm
slidingFitResultMapPair	the {micro, macro} pair of [cluster -> TwoDSlidingFitResult] maps

Definition at line 805 of file TrackRefinementBaseAlgorithm.cc.

 {
     const TwoDSlidingFitResultMap::const_iterator microFitToDelete(slidingFitResultMapPair.first->find(pClusterToRemove));
     if (microFitToDelete != slidingFitResultMapPair.first->end())
         slidingFitResultMapPair.first->erase(microFitToDelete);
 
     const TwoDSlidingFitResultMap::const_iterator macroFitToDelete(slidingFitResultMapPair.second->find(pClusterToRemove));
     if (macroFitToDelete != slidingFitResultMapPair.second->end())
         slidingFitResultMapPair.second->erase(macroFitToDelete);
 
     const ClusterVector::const_iterator clusterToDelete(std::find(clusterVector.begin(), clusterVector.end(), pClusterToRemove));
     if (clusterToDelete != clusterVector.end())
         clusterVector.erase(clusterToDelete);
 }

const Cluster * lar_content::TrackRefinementBaseAlgorithm::RemoveOffAxisHitsFromTrack	(	const pandora::Cluster *const	pCluster,
		const pandora::CartesianVector &	splitPosition,
		const bool	isEndUpstream,
		const ClusterToCaloHitListMap &	clusterToCaloHitListMap,
		pandora::ClusterList &	remnantClusterList,
		TwoDSlidingFitResultMap &	microSlidingFitResultMap,
		TwoDSlidingFitResultMap &	macroSlidingFitResultMap
	)		const

protected

Remove any hits in the upstream/downstream cluster that lie off of the main track axis (i.e. clustering errors)

Parameters

pCluster	the input cluster
splitPosition	the position after which hits are considered for removal
isEndUpstream	whether the upstream end is to be refined
clusterToCaloHitListMap	the map [parent cluster -> list of hits which belong to the main track]
remnantClusterList	the input list to store the remnant clusters
microSlidingFitResultMap	the mapping [cluster -> TwoDSlidingFitResult] where fits correspond to local gradients
macroSlidingFitResultMap	the mapping [cluster -> TwoDSlidingFitResult] where fits correspond to global cluster gradients

Returns: the address of the (possibly) modified cluster

Definition at line 496 of file TrackRefinementBaseAlgorithm.cc.

 {
     float rL(0.f), rT(0.f);
     const TwoDSlidingFitResult &microFitResult(microSlidingFitResultMap.at(pCluster));
     microFitResult.GetLocalPosition(splitPosition, rL, rT);
 
     const TwoDSlidingFitResult &macroFitResult(macroSlidingFitResultMap.at(pCluster));
     CartesianVector averageDirection(0.f, 0.f, 0.f);
     macroFitResult.GetGlobalDirection(macroFitResult.GetLayerFitResultMap().begin()->second.GetGradient(), averageDirection);
 
     const bool isVertical(std::fabs(averageDirection.GetX()) < std::numeric_limits<float>::epsilon());
     const float clusterGradient(isVertical ? 0.f : averageDirection.GetZ() / averageDirection.GetX());
     const float clusterIntercept(isVertical ? splitPosition.GetX() : splitPosition.GetZ() - (clusterGradient * splitPosition.GetX()));
 
     // Fragmentation initialisation
     std::string originalListName, fragmentListName;
     const ClusterList originalClusterList(1, pCluster);
     PANDORA_THROW_RESULT_IF(
         STATUS_CODE_SUCCESS, !=, PandoraContentApi::InitializeFragmentation(*this, originalClusterList, originalListName, fragmentListName));
 
     const Cluster *pMainTrackCluster(nullptr), *pAboveCluster(nullptr), *pBelowCluster(nullptr);
 
     const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());
     for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
     {
         for (const CaloHit *const pCaloHit : *mapEntry.second)
         {
             const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
             float thisL(0.f), thisT(0.f);
 
             microFitResult.GetLocalPosition(pCaloHit->GetPositionVector(), thisL, thisT);
 
             bool isAnExtrapolatedHit(false);
             const auto extrapolatedCaloHitIter(clusterToCaloHitListMap.find(pCluster));
 
             if (extrapolatedCaloHitIter != clusterToCaloHitListMap.end())
                 isAnExtrapolatedHit = std::find(extrapolatedCaloHitIter->second.begin(), extrapolatedCaloHitIter->second.end(), pCaloHit) !=
                                       extrapolatedCaloHitIter->second.end();
 
             const bool isAbove(((clusterGradient * hitPosition.GetX()) + clusterIntercept) < (isVertical ? hitPosition.GetX() : hitPosition.GetZ()));
             const bool isToRemove(!isAnExtrapolatedHit && (((thisL < rL) && isEndUpstream) || ((thisL > rL) && !isEndUpstream)));
 
             const Cluster *&pClusterToModify(isToRemove ? (isAbove ? pAboveCluster : pBelowCluster) : pMainTrackCluster);
 
             if (pClusterToModify)
             {
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pClusterToModify, pCaloHit));
             }
             else
             {
                 PandoraContentApi::Cluster::Parameters parameters;
                 parameters.m_caloHitList.push_back(pCaloHit);
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pClusterToModify));
 
                 if (pClusterToModify != pMainTrackCluster)
                     remnantClusterList.push_back(pClusterToModify);
             }
         }
     }
 
     // End fragmentation
     if (pAboveCluster || pBelowCluster)
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, fragmentListName, originalListName));
         return pMainTrackCluster;
     }
     else
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, originalListName, fragmentListName));
         return pCluster;
     }
 }

void lar_content::TrackRefinementBaseAlgorithm::RepositionIfInGap	(	const pandora::CartesianVector &	mergeDirection,
		pandora::CartesianVector &	trackPoint
	)		const

protected

Move an input position to the higher line gap edge if it lies within a gap.

Parameters

mergeDirection	the direction of the track
trackPoint	the input position

Definition at line 341 of file TrackRefinementBaseAlgorithm.cc.

 {
     const DetectorGapList detectorGapList(this->GetPandora().GetGeometry()->GetDetectorGapList());
     for (const DetectorGap *const pDetectorGap : detectorGapList)
     {
         const LineGap *const pLineGap(dynamic_cast<const LineGap *>(pDetectorGap));
 
         if (pLineGap)
         {
             const LineGapType lineGapType(pLineGap->GetLineGapType());
 
             if (lineGapType == TPC_DRIFT_GAP)
             {
                 if ((pLineGap->GetLineStartX() < trackPoint.GetX()) && (pLineGap->GetLineEndX() > trackPoint.GetX()))
                 {
                     if (std::fabs(mergeDirection.GetX()) < std::numeric_limits<float>::epsilon())
                         throw StatusCodeException(STATUS_CODE_FAILURE);
 
                     const float gradient(mergeDirection.GetZ() / mergeDirection.GetX());
 
                     trackPoint = CartesianVector(
                         pLineGap->GetLineEndX(), 0.f, trackPoint.GetZ() + (gradient * (pLineGap->GetLineEndX() - trackPoint.GetX())));
                 }
             }
 
             if ((lineGapType == TPC_WIRE_GAP_VIEW_U) || (lineGapType == TPC_WIRE_GAP_VIEW_V) || (lineGapType == TPC_WIRE_GAP_VIEW_W))
             {
                 if ((pLineGap->GetLineStartZ() < trackPoint.GetZ()) && (pLineGap->GetLineEndZ() > trackPoint.GetZ()))
                 {
                     if (std::fabs(mergeDirection.GetZ()) < std::numeric_limits<float>::epsilon())
                         throw StatusCodeException(STATUS_CODE_FAILURE);
 
                     const float gradient(mergeDirection.GetX() / mergeDirection.GetZ());
 
                     trackPoint = CartesianVector(
                         trackPoint.GetX() + (gradient * (pLineGap->GetLineEndZ() - trackPoint.GetZ())), 0.f, pLineGap->GetLineEndZ());
                 }
             }
         }
     }
 }

virtual pandora::StatusCode lar_content::TrackRefinementBaseAlgorithm::Run ( )

protectedpure virtual

Implemented in lar_content::TrackMergeRefinementAlgorithm.

template<typename T >

void lar_content::TrackRefinementBaseAlgorithm::UpdateContainers	(	const pandora::ClusterList &	clustersToAdd,
		const pandora::ClusterList &	clustersToDelete,
		const T	sortFunction,
		pandora::ClusterVector &	clusterVector,
		SlidingFitResultMapPair &	slidingFitResultMapPair
	)		const

protected

Remove deleted clusters from the cluster vector and sliding fit maps and add in created clusters that are determined to be track-like.

Parameters

clustersToAdd	the list of clusters to add to the containers
clustersToDelete	the list of clusters to remove from the containers
sortFunction	the sort class or function used to sort the clusterVector
clusterVector	the vector to store clusters considered within the algorithm
slidingFitResultMapPair	the {micro, macro} pair of [cluster -> TwoDSlidingFitResult] maps

template<typename T >

void lar_content::TrackRefinementBaseAlgorithm::UpdateContainers	(	const ClusterList &	clustersToAdd,
		const ClusterList &	clustersToDelete,
		const T	sortFunction,
		ClusterVector &	clusterVector,
		SlidingFitResultMapPair &	slidingFitResultMapPair
	)		const

Definition at line 793 of file TrackRefinementBaseAlgorithm.cc.

 {
     //ATTN: Very important to first delete pointers from containers
     for (const Cluster *const pClusterToDelete : clustersToDelete)
         this->RemoveClusterFromContainers(pClusterToDelete, clusterVector, slidingFitResultMapPair);
 
     this->InitialiseContainers(&clustersToAdd, sortFunction, clusterVector, slidingFitResultMapPair);
 }