CrossedTrackSplittingAlgorithm class. More...

#include <CrossedTrackSplittingAlgorithm.h>

Inheritance diagram for lar_content::CrossedTrackSplittingAlgorithm:

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

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

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

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

typedef std::vector< HitKDNode2D >	HitKDNode2DList

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

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

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

pandora::StatusCode	PreparationStep (const pandora::ClusterVector &clusterVector)
	Perform any preparatory actions, such as caching information for subsequent expensive calculations. More...

pandora::StatusCode	TidyUpStep ()
	Tidy up any information cached in e.g. the preparation step. More...

pandora::StatusCode	FindBestSplitPosition (const TwoDSlidingFitResult &slidingFit1, const TwoDSlidingFitResult &slidingFit2, pandora::CartesianVector &splitPosition, pandora::CartesianVector &direction1, pandora::CartesianVector &direction2) const
	Find the best split position and direction for a pair of clusters. More...

void	FindCandidateSplitPositions (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, pandora::CartesianPointVector &candidateVector) const
	Find average positions of pairs of hits within a maximum separation. More...

Private Attributes
float	m_maxClusterSeparation
	maximum separation of two clusters More...

float	m_maxClusterSeparationSquared
	maximum separation of two clusters (squared) More...

float	m_minCosRelativeAngle
	maximum relative angle between tracks after un-crossing More...

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

ClusterToClustersMap	m_nearbyClusters
	The nearby clusters map. More...

Additional Inherited Members
Protected Member Functions inherited from lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm
virtual pandora::StatusCode	Run ()

Detailed Description

CrossedTrackSplittingAlgorithm class.

Definition at line 28 of file CrossedTrackSplittingAlgorithm.h.

Member Typedef Documentation

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

private

Definition at line 41 of file CrossedTrackSplittingAlgorithm.h.

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

private

Definition at line 38 of file CrossedTrackSplittingAlgorithm.h.

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

private

Definition at line 39 of file CrossedTrackSplittingAlgorithm.h.

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

private

Definition at line 37 of file CrossedTrackSplittingAlgorithm.h.

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

private

Definition at line 42 of file CrossedTrackSplittingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::CrossedTrackSplittingAlgorithm::CrossedTrackSplittingAlgorithm ( )

Default constructor.

Definition at line 23 of file CrossedTrackSplittingAlgorithm.cc.

                                                                :
     m_maxClusterSeparation(2.f),
     m_maxClusterSeparationSquared(m_maxClusterSeparation * m_maxClusterSeparation),
     m_minCosRelativeAngle(0.966f),
     m_searchRegion1D(2.f)
 {
 }

Member Function Documentation

StatusCode lar_content::CrossedTrackSplittingAlgorithm::FindBestSplitPosition	(	const TwoDSlidingFitResult &	slidingFit1,
		const TwoDSlidingFitResult &	slidingFit2,
		pandora::CartesianVector &	splitPosition,
		pandora::CartesianVector &	direction1,
		pandora::CartesianVector &	direction2
	)		const

privatevirtual

Find the best split position and direction for a pair of clusters.

Parameters

slidingFit1	the sliding linear fit to the first cluster
slidingFit2	the sliding linear fit to the second cluster
splitPosition	the output split position
direction1	the output direction of the first new cluster
direction2	the output direction of the second new cluster

Implements lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm.

Definition at line 86 of file CrossedTrackSplittingAlgorithm.cc.

 {
     // Use cached results from kd-tree to avoid expensive calculations
     if (!m_nearbyClusters.count(slidingFitResult1.GetCluster()) || !m_nearbyClusters.count(slidingFitResult2.GetCluster()) ||
         !m_nearbyClusters.at(slidingFitResult1.GetCluster()).count(slidingFitResult2.GetCluster()) ||
         !m_nearbyClusters.at(slidingFitResult2.GetCluster()).count(slidingFitResult1.GetCluster()))
     {
         return STATUS_CODE_NOT_FOUND;
     }
 
     // Identify crossed-track topology and find candidate intersection positions
     const CartesianVector &minPosition1(slidingFitResult1.GetGlobalMinLayerPosition());
     const CartesianVector &maxPosition1(slidingFitResult1.GetGlobalMaxLayerPosition());
 
     const CartesianVector &minPosition2(slidingFitResult2.GetGlobalMinLayerPosition());
     const CartesianVector &maxPosition2(slidingFitResult2.GetGlobalMaxLayerPosition());
 
     if (LArClusterHelper::GetClosestDistance(minPosition1, slidingFitResult2.GetCluster()) < 2.f * m_maxClusterSeparation ||
         LArClusterHelper::GetClosestDistance(maxPosition1, slidingFitResult2.GetCluster()) < 2.f * m_maxClusterSeparation ||
         LArClusterHelper::GetClosestDistance(minPosition2, slidingFitResult1.GetCluster()) < 2.f * m_maxClusterSeparation ||
         LArClusterHelper::GetClosestDistance(maxPosition2, slidingFitResult1.GetCluster()) < 2.f * m_maxClusterSeparation)
     {
         return STATUS_CODE_NOT_FOUND;
     }
 
     if (LArClusterHelper::GetClosestDistance(slidingFitResult1.GetCluster(), slidingFitResult2.GetCluster()) > m_maxClusterSeparation)
         return STATUS_CODE_NOT_FOUND;
 
     CartesianPointVector candidateVector;
     this->FindCandidateSplitPositions(slidingFitResult1.GetCluster(), slidingFitResult2.GetCluster(), candidateVector);
 
     if (candidateVector.empty())
         return STATUS_CODE_NOT_FOUND;
 
     // Loop over candidate positions and find best split position
     bool foundSplit(false);
     float closestSeparationSquared(std::numeric_limits<float>::max());
 
     const float halfWindowLength1(slidingFitResult1.GetLayerFitHalfWindowLength());
     const float halfWindowLength2(slidingFitResult2.GetLayerFitHalfWindowLength());
 
     for (CartesianPointVector::const_iterator iter = candidateVector.begin(), iterEnd = candidateVector.end(); iter != iterEnd; ++iter)
     {
         const CartesianVector &candidatePosition(*iter);
 
         // Projections onto first cluster
         float rL1(0.f), rT1(0.f);
         CartesianVector R1(0.f, 0.f, 0.f);
         CartesianVector F1(0.f, 0.f, 0.f);
         CartesianVector B1(0.f, 0.f, 0.f);
 
         if (STATUS_CODE_SUCCESS != slidingFitResult1.GetGlobalFitProjection(candidatePosition, R1))
             continue;
 
         slidingFitResult1.GetLocalPosition(R1, rL1, rT1);
         if ((STATUS_CODE_SUCCESS != slidingFitResult1.GetGlobalFitPosition(rL1 + halfWindowLength1, F1)) ||
             (STATUS_CODE_SUCCESS != slidingFitResult1.GetGlobalFitPosition(rL1 - halfWindowLength1, B1)))
         {
             continue;
         }
 
         // Projections onto second cluster
         float rL2(0.f), rT2(0.f);
         CartesianVector R2(0.f, 0.f, 0.f);
         CartesianVector F2(0.f, 0.f, 0.f);
         CartesianVector B2(0.f, 0.f, 0.f);
 
         if (STATUS_CODE_SUCCESS != slidingFitResult2.GetGlobalFitProjection(candidatePosition, R2))
             continue;
 
         slidingFitResult2.GetLocalPosition(R2, rL2, rT2);
         if ((STATUS_CODE_SUCCESS != slidingFitResult2.GetGlobalFitPosition(rL2 + halfWindowLength2, F2)) ||
             (STATUS_CODE_SUCCESS != slidingFitResult2.GetGlobalFitPosition(rL2 - halfWindowLength2, B2)))
         {
             continue;
         }
 
         // Calculate average position
         const CartesianVector C0((R1 + R2) * 0.5);
 
         // Calculate intersected position:
         // ==============================
         // First cluster gives set of points: B1->R1->F1
         // Second cluster gives set of points: B2->R2->F2
         //
         // Try swapping B1 with B2 to see if this gives intersecting straight lines:
         //
         //   F1   F2     a2   b1
         //    |   |       |   |
         //     |  |        |  |
         //     R1 R2       R1 R2
         //      | |         |  |
         //      |  |        |   |
         //     B1   B2     a1    b2
 
         // First straight line is a1->R1->b1
         // Second straight line is a2->R2->b2
 
         const CartesianVector a1(B1);
         const CartesianVector a2(F1);
 
         for (unsigned int iForward = 0; iForward < 2; ++iForward)
         {
             const CartesianVector b1((0 == iForward) ? F2 : B2);
             const CartesianVector b2((0 == iForward) ? B2 : F2);
 
             const CartesianVector s1((b1 - R2).GetUnitVector());
             const CartesianVector t1((R1 - a1).GetUnitVector());
             const CartesianVector s2((b2 - R2).GetUnitVector());
             const CartesianVector t2((R1 - a2).GetUnitVector());
 
             if (s1.GetDotProduct(t1) < std::max(m_minCosRelativeAngle, -s1.GetDotProduct(s2)) ||
                 s2.GetDotProduct(t2) < std::max(m_minCosRelativeAngle, -t1.GetDotProduct(t2)))
                 continue;
 
             const CartesianVector p1((b1 - a1).GetUnitVector());
             const CartesianVector p2((b2 - a2).GetUnitVector());
 
             float mu1(0.f), mu2(0.f);
             CartesianVector C1(0.f, 0.f, 0.f);
 
             try
             {
                 LArPointingClusterHelper::GetIntersection(a1, p1, a2, p2, C1, mu1, mu2);
             }
             catch (const StatusCodeException &)
             {
                 continue;
             }
 
             if (mu1 < 0.f || mu2 < 0.f || mu1 > (b1 - a1).GetMagnitude() || mu2 > (b2 - a2).GetMagnitude())
                 continue;
 
             const float thisSeparationSquared((C0 - C1).GetMagnitudeSquared());
 
             if (thisSeparationSquared < closestSeparationSquared)
             {
                 closestSeparationSquared = thisSeparationSquared;
                 splitPosition = (C0 + C1) * 0.5;
                 firstDirection = t2 * -1.f;
                 secondDirection = t1;
                 foundSplit = true;
             }
         }
     }
 
     if (!foundSplit)
         return STATUS_CODE_NOT_FOUND;
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::CrossedTrackSplittingAlgorithm::FindCandidateSplitPositions	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		pandora::CartesianPointVector &	candidateVector
	)		const

private

Find average positions of pairs of hits within a maximum separation.

Parameters

pCluster1	the first cluster
pCluster2	the second cluster
candidateVector	to receive the average positions

Definition at line 241 of file CrossedTrackSplittingAlgorithm.cc.

 {
     // ATTN The following is double-double counting
     CaloHitList caloHitList1, caloHitList2;
     pCluster1->GetOrderedCaloHitList().FillCaloHitList(caloHitList1);
     pCluster2->GetOrderedCaloHitList().FillCaloHitList(caloHitList2);
 
     CaloHitVector caloHitVector1(caloHitList1.begin(), caloHitList1.end()), caloHitVector2(caloHitList2.begin(), caloHitList2.end());
     std::sort(caloHitVector1.begin(), caloHitVector1.end(), LArClusterHelper::SortHitsByPosition);
     std::sort(caloHitVector2.begin(), caloHitVector2.end(), LArClusterHelper::SortHitsByPosition);
 
     for (const CaloHit *const pCaloHit : caloHitVector1)
     {
         const CartesianVector position1(pCaloHit->GetPositionVector());
         const CartesianVector position2(LArClusterHelper::GetClosestPosition(position1, pCluster2));
 
         if ((position1 - position2).GetMagnitudeSquared() < m_maxClusterSeparationSquared)
             candidateVector.push_back((position1 + position2) * 0.5);
     }
 
     for (const CaloHit *const pCaloHit : caloHitVector2)
     {
         const CartesianVector position2(pCaloHit->GetPositionVector());
         const CartesianVector position1(LArClusterHelper::GetClosestPosition(position2, pCluster1));
 
         if ((position2 - position1).GetMagnitudeSquared() < m_maxClusterSeparationSquared)
             candidateVector.push_back((position2 + position1) * 0.5);
     }
 }

StatusCode lar_content::CrossedTrackSplittingAlgorithm::PreparationStep ( const pandora::ClusterVector & clusterVector )

privatevirtual

Perform any preparatory actions, such as caching information for subsequent expensive calculations.

Parameters

clusterVector the cluster vector

Reimplemented from lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm.

Definition at line 33 of file CrossedTrackSplittingAlgorithm.cc.

 {
     // ATTN Don't need to update nearby cluster map after cluster merges because algorithm does not revisit processed clusters
     HitToClusterMap hitToClusterMap;
     CaloHitList allCaloHits;
 
     for (const Cluster *const pCluster : clusterVector)
     {
         CaloHitList daughterHits;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(daughterHits);
         allCaloHits.insert(allCaloHits.end(), daughterHits.begin(), daughterHits.end());
 
         for (const CaloHit *const pCaloHit : daughterHits)
             (void)hitToClusterMap.insert(HitToClusterMap::value_type(pCaloHit, pCluster));
     }
 
     HitKDTree2D kdTree;
     HitKDNode2DList hitKDNode2DList;
 
     KDTreeBox hitsBoundingRegion2D(fill_and_bound_2d_kd_tree(allCaloHits, hitKDNode2DList));
     kdTree.build(hitKDNode2DList, hitsBoundingRegion2D);
 
     for (const Cluster *const pCluster : clusterVector)
     {
         CaloHitList daughterHits;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(daughterHits);
 
         for (const CaloHit *const pCaloHit : daughterHits)
         {
             KDTreeBox searchRegionHits(build_2d_kd_search_region(pCaloHit, m_searchRegion1D, m_searchRegion1D));
 
             HitKDNode2DList found;
             kdTree.search(searchRegionHits, found);
 
             for (const auto &hit : found)
                 (void)m_nearbyClusters[pCluster].insert(hitToClusterMap.at(hit.data));
         }
     }
 
     return STATUS_CODE_SUCCESS;
 }

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

privatevirtual

Reimplemented from lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm.

Definition at line 274 of file CrossedTrackSplittingAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxClusterSeparation", m_maxClusterSeparation));
     m_maxClusterSeparationSquared = m_maxClusterSeparation * m_maxClusterSeparation;
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCosRelativeAngle", m_minCosRelativeAngle));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SearchRegion1D", m_searchRegion1D));
 
     return TwoDSlidingFitSplittingAndSwitchingAlgorithm::ReadSettings(xmlHandle);
 }

StatusCode lar_content::CrossedTrackSplittingAlgorithm::TidyUpStep ( )

privatevirtual

Tidy up any information cached in e.g. the preparation step.

Reimplemented from lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm.

Definition at line 77 of file CrossedTrackSplittingAlgorithm.cc.

 {
     m_nearbyClusters.clear();
 
     return STATUS_CODE_SUCCESS;
 }

Member Data Documentation

float lar_content::CrossedTrackSplittingAlgorithm::m_maxClusterSeparation

private

maximum separation of two clusters

Definition at line 60 of file CrossedTrackSplittingAlgorithm.h.

float lar_content::CrossedTrackSplittingAlgorithm::m_maxClusterSeparationSquared

private

maximum separation of two clusters (squared)

Definition at line 61 of file CrossedTrackSplittingAlgorithm.h.

float lar_content::CrossedTrackSplittingAlgorithm::m_minCosRelativeAngle

private

maximum relative angle between tracks after un-crossing

Definition at line 62 of file CrossedTrackSplittingAlgorithm.h.

ClusterToClustersMap lar_content::CrossedTrackSplittingAlgorithm::m_nearbyClusters

private

The nearby clusters map.

Definition at line 65 of file CrossedTrackSplittingAlgorithm.h.

float lar_content::CrossedTrackSplittingAlgorithm::m_searchRegion1D

private

Search region, applied to each dimension, for look-up from kd-trees.

Definition at line 64 of file CrossedTrackSplittingAlgorithm.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation