TwoDSlidingFitSplittingAndSwitchingAlgorithm class. More...

#include <TwoDSlidingFitSplittingAndSwitchingAlgorithm.h>

Inheritance diagram for lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm:

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

Protected Member Functions
virtual pandora::StatusCode	Run ()

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

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

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

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

Private Member Functions
void	GetListOfCleanClusters (const pandora::ClusterList *const pClusterList, pandora::ClusterVector &clusterVector) const
	Populate cluster vector with subset of cluster list, containing clusters judged to be clean. More...

void	BuildSlidingFitResultMap (const pandora::ClusterVector &clusterVector, TwoDSlidingFitResultMap &slidingFitResultMap) const
	Build the map of sliding fit results. More...

void	SplitCluster (const pandora::Cluster *const pCluster, const pandora::CartesianVector &splitPosition, const pandora::CartesianVector &splitDirection, pandora::CaloHitList &firstCaloHitList, pandora::CaloHitList &secondCaloHitList) const
	Split cluster at a given position and direction. More...

pandora::StatusCode	ReplaceClusters (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, const pandora::CartesianVector &splitPosition, const pandora::CartesianVector &firstDirection, const pandora::CartesianVector &secondDirection) const
	Replace crossed clusters with un-crossed clusters. More...

Private Attributes
unsigned int	m_halfWindowLayers
	half window layers for sliding linear fot More...

float	m_minClusterLength
	minimum length of clusters More...

Detailed Description

TwoDSlidingFitSplittingAndSwitchingAlgorithm class.

Definition at line 21 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::TwoDSlidingFitSplittingAndSwitchingAlgorithm ( )

Default constructor.

Definition at line 21 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.cc.

                                                                                            :
     m_halfWindowLayers(25),
     m_minClusterLength(10.f)
 {
 }

Member Function Documentation

void lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::BuildSlidingFitResultMap	(	const pandora::ClusterVector &	clusterVector,
		TwoDSlidingFitResultMap &	slidingFitResultMap
	)		const

private

Build the map of sliding fit results.

Parameters

clusterVector	the input cluster vector
slidingFitResultMap	the output sliding fit result map

Definition at line 132 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.cc.

 {
     const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
 
     for (ClusterVector::const_iterator iter = clusterVector.begin(), iterEnd = clusterVector.end(); iter != iterEnd; ++iter)
     {
         if (slidingFitResultMap.end() == slidingFitResultMap.find(*iter))
         {
             try
             {
                 const TwoDSlidingFitResult slidingFitResult(*iter, m_halfWindowLayers, slidingFitPitch);
 
                 if (!slidingFitResultMap.insert(TwoDSlidingFitResultMap::value_type(*iter, slidingFitResult)).second)
                     throw StatusCodeException(STATUS_CODE_FAILURE);
             }
             catch (StatusCodeException &statusCodeException)
             {
                 if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                     throw statusCodeException;
             }
         }
     }
 }

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

protectedpure virtual

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

Implemented in lar_content::CrossedTrackSplittingAlgorithm.

void lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::GetListOfCleanClusters	(	const pandora::ClusterList *const	pClusterList,
		pandora::ClusterVector &	clusterVector
	)		const

private

Populate cluster vector with subset of cluster list, containing clusters judged to be clean.

Parameters

pClusterList	address of the cluster list
clusterVector	to receive the populated cluster vector

Definition at line 115 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.cc.

 {
     for (ClusterList::const_iterator iter = pClusterList->begin(), iterEnd = pClusterList->end(); iter != iterEnd; ++iter)
     {
         const Cluster *const pCluster = *iter;
 
         if (LArClusterHelper::GetLengthSquared(pCluster) < m_minClusterLength * m_minClusterLength)
             continue;
 
         clusterVector.push_back(pCluster);
     }
 
     std::sort(clusterVector.begin(), clusterVector.end(), LArClusterHelper::SortByNHits);
 }

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

protectedvirtual

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

Parameters

clusterVector the cluster vector

Reimplemented in lar_content::CrossedTrackSplittingAlgorithm.

Definition at line 101 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.cc.

 {
     return STATUS_CODE_SUCCESS;
 }

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

protectedvirtual

Reimplemented in lar_content::CrossedTrackSplittingAlgorithm.

Definition at line 216 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "HalfWindowLayers", m_halfWindowLayers));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterLength", m_minClusterLength));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::ReplaceClusters	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		const pandora::CartesianVector &	splitPosition,
		const pandora::CartesianVector &	firstDirection,
		const pandora::CartesianVector &	secondDirection
	)		const

private

Replace crossed clusters with un-crossed clusters.

Parameters

pCluster1	the first cluster to be deleted
pCluster2	the second cluster to be deleted
splitPosition	the split position
firstDirection	the direction of the first new cluster
secondDirection	the direction of the second new cluster

Definition at line 182 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.cc.

 {
     // Split cluster into two hit lists (note the convention for 'firstDirection' and 'secondDirection')
     PandoraContentApi::Cluster::Parameters firstParameters, secondParameters;
 
     this->SplitCluster(pCluster1, splitPosition, firstDirection, firstParameters.m_caloHitList, secondParameters.m_caloHitList);
     this->SplitCluster(pCluster2, splitPosition, secondDirection, secondParameters.m_caloHitList, firstParameters.m_caloHitList);
 
     if (firstParameters.m_caloHitList.empty() || secondParameters.m_caloHitList.empty())
         return STATUS_CODE_NOT_ALLOWED;
 
     // Begin cluster fragmentation operations
     ClusterList clusterList;
     clusterList.push_back(pCluster1);
     clusterList.push_back(pCluster2);
 
     std::string clusterListToSaveName, clusterListToDeleteName;
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         PandoraContentApi::InitializeFragmentation(*this, clusterList, clusterListToDeleteName, clusterListToSaveName));
 
     // Create new clusters
     const Cluster *pFirstCluster(NULL), *pSecondCluster(NULL);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, firstParameters, pFirstCluster));
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, secondParameters, pSecondCluster));
 
     // End cluster fragmentation operations
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, clusterListToSaveName, clusterListToDeleteName));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::Run ( )

protectedvirtual

Definition at line 29 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.cc.

 {
     const ClusterList *pClusterList = NULL;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pClusterList));
 
     // Get ordered list of clean clusters
     ClusterVector clusterVector;
     this->GetListOfCleanClusters(pClusterList, clusterVector);
 
     // Calculate sliding fit results for clean clusters
     TwoDSlidingFitResultMap slidingFitResultMap;
     this->BuildSlidingFitResultMap(clusterVector, slidingFitResultMap);
 
     // May choose to cache information here, for subsequent expensive calculations
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->PreparationStep(clusterVector));
 
     // Loop over clusters, identify split positions, perform splits
     for (ClusterVector::iterator iter1 = clusterVector.begin(), iterEnd1 = clusterVector.end(); iter1 != iterEnd1; ++iter1)
     {
         if (NULL == *iter1)
             continue;
 
         TwoDSlidingFitResultMap::iterator sIter1 = slidingFitResultMap.find(*iter1);
 
         if (slidingFitResultMap.end() == sIter1)
             continue;
 
         const TwoDSlidingFitResult &slidingFitResult1(sIter1->second);
 
         for (ClusterVector::iterator iter2 = iter1, iterEnd2 = iterEnd1; iter2 != iterEnd2; ++iter2)
         {
             if (NULL == *iter2)
                 continue;
 
             TwoDSlidingFitResultMap::iterator sIter2 = slidingFitResultMap.find(*iter2);
 
             if (slidingFitResultMap.end() == sIter2)
                 continue;
 
             const TwoDSlidingFitResult &slidingFitResult2(sIter2->second);
 
             if (slidingFitResult1.GetCluster() == slidingFitResult2.GetCluster())
                 continue;
 
             CartesianVector splitPosition(0.f, 0.f, 0.f);
             CartesianVector firstDirection(0.f, 0.f, 0.f);
             CartesianVector secondDirection(0.f, 0.f, 0.f);
 
             if (STATUS_CODE_SUCCESS != this->FindBestSplitPosition(slidingFitResult1, slidingFitResult2, splitPosition, firstDirection, secondDirection))
                 continue;
 
             const Cluster *const pCluster1 = slidingFitResult1.GetCluster();
             const Cluster *const pCluster2 = slidingFitResult2.GetCluster();
 
             if (STATUS_CODE_SUCCESS != this->ReplaceClusters(pCluster1, pCluster2, splitPosition, firstDirection, secondDirection))
                 continue;
 
             slidingFitResultMap.erase(sIter1);
             slidingFitResultMap.erase(sIter2);
 
             *iter1 = NULL;
             *iter2 = NULL;
 
             break;
         }
     }
 
     return this->TidyUpStep();
 }

void lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::SplitCluster	(	const pandora::Cluster *const	pCluster,
		const pandora::CartesianVector &	splitPosition,
		const pandora::CartesianVector &	splitDirection,
		pandora::CaloHitList &	firstCaloHitList,
		pandora::CaloHitList &	secondCaloHitList
	)		const

private

Split cluster at a given position and direction.

Parameters

pCluster	the cluster
splitPosition	the position at which to split the cluster
splitDirection	the direction of the un-crossed cluster
firstCaloHitList	the hits to be added to the first new cluster
secondCaloHitList	the hits to be added to the second new cluster

Definition at line 159 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.cc.

 {
     CaloHitList caloHitsToDistribute;
     pCluster->GetOrderedCaloHitList().FillCaloHitList(caloHitsToDistribute);
 
     for (CaloHitList::const_iterator iter = caloHitsToDistribute.begin(), iterEnd = caloHitsToDistribute.end(); iter != iterEnd; ++iter)
     {
         const CaloHit *const pCaloHit = *iter;
 
         if (splitDirection.GetDotProduct((pCaloHit->GetPositionVector() - splitPosition)) > 0.f)
         {
             firstCaloHitList.push_back(pCaloHit);
         }
         else
         {
             secondCaloHitList.push_back(pCaloHit);
         }
     }
 }

StatusCode lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::TidyUpStep ( )

protectedvirtual

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

Reimplemented in lar_content::CrossedTrackSplittingAlgorithm.

Definition at line 108 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.cc.

 {
     return STATUS_CODE_SUCCESS;
 }

Member Data Documentation

unsigned int lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::m_halfWindowLayers

private

half window layers for sliding linear fot

Definition at line 99 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.h.

float lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::m_minClusterLength

private

minimum length of clusters

Definition at line 100 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.h.

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

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation