TwoDSlidingFitSplittingAndSplicingAlgorithm class. More...

#include <TwoDSlidingFitSplittingAndSplicingAlgorithm.h>

Inheritance diagram for lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm:

Classes
class	ClusterExtension
	ClusterExtension class. More...

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

Protected Types
typedef std::vector < ClusterExtension >	ClusterExtensionList

Protected Member Functions
virtual pandora::StatusCode	Run ()

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

virtual void	FindBestSplitPosition (const TwoDSlidingFitResult &branchSlidingFit, const TwoDSlidingFitResult &replacementSlidingFit, pandora::CartesianVector &replacementStartPosition, pandora::CartesianVector &branchSplitPosition, pandora::CartesianVector &branchSplitDirection) const =0
	Output the best split positions in branch and replacement 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, const unsigned int halfWindowLayers, TwoDSlidingFitResultMap &slidingFitResultMap) const
	Build the map of sliding fit results. More...

void	BuildClusterExtensionList (const pandora::ClusterVector &clusterVector, const TwoDSlidingFitResultMap &branchResultMap, const TwoDSlidingFitResultMap &replacementResultMap, ClusterExtensionList &clusterExtensionList) const
	Build a list of candidate splits. More...

void	PruneClusterExtensionList (const ClusterExtensionList &inputList, const TwoDSlidingFitResultMap &branchResultMap, const TwoDSlidingFitResultMap &replacementResultMap, ClusterExtensionList &outputList) const
	Finalize the list of candidate splits. More...

float	CalculateBranchChi2 (const pandora::Cluster *const pCluster, const pandora::CartesianVector &splitPosition, const pandora::CartesianVector &splitDirection) const
	Calculate RMS deviation of branch hits relative to the split direction. More...

void	SplitBranchCluster (const pandora::Cluster *const pCluster, const pandora::CartesianVector &splitPosition, const pandora::CartesianVector &splitDirection, pandora::CaloHitList &principalCaloHitList, pandora::CaloHitList &branchCaloHitList) const
	Separate cluster into the branch hits to be split from the primary cluster. More...

pandora::StatusCode	RunSplitAndExtension (const ClusterExtensionList &splitList, TwoDSlidingFitResultMap &branchResultMap, TwoDSlidingFitResultMap &replacementResultMap) const
	Run the machinary that performs the cluster splitting and extending. More...

pandora::StatusCode	ReplaceBranch (const pandora::Cluster const pBranchCluster, const pandora::Cluster const pReplacementCluster, const pandora::CartesianVector &branchSplitPosition, const pandora::CartesianVector &branchSplitDirection) const
	Remove a branch from a cluster and replace it with a second cluster. More...

Private Attributes
unsigned int	m_shortHalfWindowLayers

unsigned int	m_longHalfWindowLayers

float	m_minClusterLength

float	m_vetoDisplacement

bool	m_runCosmicMode

Detailed Description

TwoDSlidingFitSplittingAndSplicingAlgorithm class.

Definition at line 21 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.h.

Member Typedef Documentation

typedef std::vector<ClusterExtension> lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::ClusterExtensionList

protected

Definition at line 85 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::TwoDSlidingFitSplittingAndSplicingAlgorithm ( )

Default constructor.

Definition at line 21 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.cc.

                                                                                          :
     m_shortHalfWindowLayers(10),
     m_longHalfWindowLayers(20),
     m_minClusterLength(7.5f),
     m_vetoDisplacement(1.5f),
     m_runCosmicMode(false)
 {
 }

Member Function Documentation

void lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::BuildClusterExtensionList	(	const pandora::ClusterVector &	clusterVector,
		const TwoDSlidingFitResultMap &	branchResultMap,
		const TwoDSlidingFitResultMap &	replacementResultMap,
		ClusterExtensionList &	clusterExtensionList
	)		const

private

Build a list of candidate splits.

Parameters

clusterVector	the input cluster vector
branchResultMap	the sliding fit result map for branch clusters
replacementResultMap	the sliding fit result map for replacement clusters
clusterExtensionList	the output list of candidate splits

Definition at line 121 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.cc.

 {
     // Loop over each possible pair of clusters
     for (ClusterVector::const_iterator iterI = clusterVector.begin(), iterEndI = clusterVector.end(); iterI != iterEndI; ++iterI)
     {
         const Cluster *const pClusterI = *iterI;
 
         for (ClusterVector::const_iterator iterJ = iterI, iterEndJ = clusterVector.end(); iterJ != iterEndJ; ++iterJ)
         {
             const Cluster *const pClusterJ = *iterJ;
 
             if (pClusterI == pClusterJ)
                 continue;
 
             // Get the branch and replacement sliding fits for this pair of clusters
             TwoDSlidingFitResultMap::const_iterator iterBranchI = branchSlidingFitResultMap.find(*iterI);
             TwoDSlidingFitResultMap::const_iterator iterBranchJ = branchSlidingFitResultMap.find(*iterJ);
 
             TwoDSlidingFitResultMap::const_iterator iterReplacementI = replacementSlidingFitResultMap.find(*iterI);
             TwoDSlidingFitResultMap::const_iterator iterReplacementJ = replacementSlidingFitResultMap.find(*iterJ);
 
             if (branchSlidingFitResultMap.end() == iterBranchI || branchSlidingFitResultMap.end() == iterBranchJ ||
                 replacementSlidingFitResultMap.end() == iterReplacementI || replacementSlidingFitResultMap.end() == iterReplacementJ)
             {
                 // TODO May want to raise an exception under certain conditions
                 continue;
             }
 
             const TwoDSlidingFitResult &branchSlidingFitI(iterBranchI->second);
             const TwoDSlidingFitResult &branchSlidingFitJ(iterBranchJ->second);
 
             const TwoDSlidingFitResult &replacementSlidingFitI(iterReplacementI->second);
             const TwoDSlidingFitResult &replacementSlidingFitJ(iterReplacementJ->second);
 
             // Search for a split in clusterI
             float branchChisqI(0.f);
             CartesianVector branchSplitPositionI(0.f, 0.f, 0.f);
             CartesianVector branchSplitDirectionI(0.f, 0.f, 0.f);
             CartesianVector replacementStartPositionJ(0.f, 0.f, 0.f);
 
             try
             {
                 this->FindBestSplitPosition(branchSlidingFitI, replacementSlidingFitJ, replacementStartPositionJ, branchSplitPositionI, branchSplitDirectionI);
                 branchChisqI = this->CalculateBranchChi2(pClusterI, branchSplitPositionI, branchSplitDirectionI);
             }
             catch (StatusCodeException &)
             {
             }
 
             // Search for a split in clusterJ
             float branchChisqJ(0.f);
             CartesianVector branchSplitPositionJ(0.f, 0.f, 0.f);
             CartesianVector branchSplitDirectionJ(0.f, 0.f, 0.f);
             CartesianVector replacementStartPositionI(0.f, 0.f, 0.f);
 
             try
             {
                 this->FindBestSplitPosition(branchSlidingFitJ, replacementSlidingFitI, replacementStartPositionI, branchSplitPositionJ, branchSplitDirectionJ);
                 branchChisqJ = this->CalculateBranchChi2(pClusterJ, branchSplitPositionJ, branchSplitDirectionJ);
             }
             catch (StatusCodeException &)
             {
             }
 
             // Re-calculate chi2 values if both clusters have a split
             if (branchChisqI > 0.f && branchChisqJ > 0.f)
             {
                 const CartesianVector relativeDirection((branchSplitPositionJ - branchSplitPositionI).GetUnitVector());
 
                 if (branchSplitDirectionI.GetDotProduct(relativeDirection) > 0.f && branchSplitDirectionJ.GetDotProduct(relativeDirection) < 0.f)
                 {
                     try
                     {
                         const float newBranchChisqI(this->CalculateBranchChi2(pClusterI, branchSplitPositionI, relativeDirection));
                         const float newBranchChisqJ(this->CalculateBranchChi2(pClusterJ, branchSplitPositionJ, relativeDirection * -1.f));
                         branchChisqI = newBranchChisqI;
                         branchChisqJ = newBranchChisqJ;
                     }
                     catch (StatusCodeException &)
                     {
                     }
                 }
             }
 
             // Select the overall best split position
             if (branchChisqI > branchChisqJ)
             {
                 clusterExtensionList.push_back(
                     ClusterExtension(pClusterI, pClusterJ, replacementStartPositionJ, branchSplitPositionI, branchSplitDirectionI));
             }
 
             else if (branchChisqJ > branchChisqI)
             {
                 clusterExtensionList.push_back(
                     ClusterExtension(pClusterJ, pClusterI, replacementStartPositionI, branchSplitPositionJ, branchSplitDirectionJ));
             }
         }
     }
 }

void lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::BuildSlidingFitResultMap	(	const pandora::ClusterVector &	clusterVector,
		const unsigned int	halfWindowLayers,
		TwoDSlidingFitResultMap &	slidingFitResultMap
	)		const

private

Build the map of sliding fit results.

Parameters

clusterVector	the input cluster vector
halfWindowLayers	the half-window to use for the sliding fits
slidingFitResultMap	the output sliding fit result map

Definition at line 94 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.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, 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;
             }
         }
     }
 }

float lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::CalculateBranchChi2	(	const pandora::Cluster *const	pCluster,
		const pandora::CartesianVector &	splitPosition,
		const pandora::CartesianVector &	splitDirection
	)		const

private

Calculate RMS deviation of branch hits relative to the split direction.

Parameters

pCluster	the input branch cluster
splitPosition	the start position of the branch
splitDirection	the start direction of the branch

Definition at line 293 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.cc.

 {
     CaloHitList principalCaloHitList, branchCaloHitList;
 
     this->SplitBranchCluster(pCluster, splitPosition, splitDirection, principalCaloHitList, branchCaloHitList);
 
     float totalChi2(0.f);
     float totalHits(0.f);
 
     for (CaloHitList::const_iterator iter = branchCaloHitList.begin(), iterEnd = branchCaloHitList.end(); iter != iterEnd; ++iter)
     {
         const CaloHit *const pCaloHit = *iter;
 
         const CartesianVector hitPosition(pCaloHit->GetPositionVector());
         const CartesianVector projectedPosition(splitPosition + splitDirection * splitDirection.GetDotProduct(hitPosition - splitPosition));
 
         totalChi2 += (hitPosition - projectedPosition).GetMagnitudeSquared();
         totalHits += 1.f;
     }
 
     if (totalHits > 0.f)
         return std::sqrt(totalChi2 / totalHits);
 
     throw StatusCodeException(STATUS_CODE_NOT_ALLOWED);
 }

virtual void lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::FindBestSplitPosition	(	const TwoDSlidingFitResult &	branchSlidingFit,
		const TwoDSlidingFitResult &	replacementSlidingFit,
		pandora::CartesianVector &	replacementStartPosition,
		pandora::CartesianVector &	branchSplitPosition,
		pandora::CartesianVector &	branchSplitDirection
	)		const

protectedpure virtual

Output the best split positions in branch and replacement clusters.

Parameters

branchSlidingFit	the inputted sliding fit result for possible branch cluster
pReplacementCluster	the inputted sliding fit result for possible replacement cluster
replacementStartPosition	the outputted start position of the replacement
branchSplitPosition	the outputted start position of the branch
branchSplitDirection	the outputted start direction of the branch

Implemented in lar_content::BranchSplittingAlgorithm, and lar_content::DeltaRaySplittingAlgorithm.

void lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::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 77 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.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);
 }

void lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::PruneClusterExtensionList	(	const ClusterExtensionList &	inputList,
		const TwoDSlidingFitResultMap &	branchResultMap,
		const TwoDSlidingFitResultMap &	replacementResultMap,
		ClusterExtensionList &	outputList
	)		const

private

Finalize the list of candidate splits.

Parameters

inputList	the input list of possible splits
branchResultMap	the sliding fit result map for branch clusters
replacementResultMap	the sliding fit result map for replacement clusters
outputList	the output list of definite splits

Definition at line 225 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.cc.

 {
     ClusterList branchList;
     for (const auto &mapEntry : branchMap)
         branchList.push_back(mapEntry.first);
     branchList.sort(LArClusterHelper::SortByNHits);
 
     ClusterList replacementList;
     for (const auto &mapEntry : replacementMap)
         replacementList.push_back(mapEntry.first);
     replacementList.sort(LArClusterHelper::SortByNHits);
 
     for (const ClusterExtension &thisSplit : inputList)
     {
         const CartesianVector &branchVertex = thisSplit.GetBranchVertex();
         const CartesianVector &replacementVertex = thisSplit.GetReplacementVertex();
 
         const float distanceSquared((branchVertex - replacementVertex).GetMagnitudeSquared());
         const float vetoDistanceSquared(m_vetoDisplacement * m_vetoDisplacement);
 
         bool branchVeto(false), replacementVeto(false);
 
         // Veto the merge if another cluster is closer to the replacement vertex
         for (const Cluster *const pBranchCluster : branchList)
         {
             const TwoDSlidingFitResult &slidingFit(branchMap.at(pBranchCluster));
 
             if (slidingFit.GetCluster() == thisSplit.GetReplacementCluster() || slidingFit.GetCluster() == thisSplit.GetBranchCluster())
                 continue;
 
             const float minDistanceSquared((replacementVertex - slidingFit.GetGlobalMinLayerPosition()).GetMagnitudeSquared());
             const float maxDistanceSquared((replacementVertex - slidingFit.GetGlobalMaxLayerPosition()).GetMagnitudeSquared());
 
             if (std::min(minDistanceSquared, maxDistanceSquared) < std::max(distanceSquared, vetoDistanceSquared))
             {
                 branchVeto = true;
                 break;
             }
         }
 
         // Veto the merge if another cluster is closer to the branch vertex
         for (const Cluster *const pReplacementCluster : replacementList)
         {
             const TwoDSlidingFitResult &slidingFit(replacementMap.at(pReplacementCluster));
 
             if (slidingFit.GetCluster() == thisSplit.GetReplacementCluster() || slidingFit.GetCluster() == thisSplit.GetBranchCluster())
                 continue;
 
             const float minDistanceSquared((branchVertex - slidingFit.GetGlobalMinLayerPosition()).GetMagnitudeSquared());
             const float maxDistanceSquared((branchVertex - slidingFit.GetGlobalMaxLayerPosition()).GetMagnitudeSquared());
 
             if (std::min(minDistanceSquared, maxDistanceSquared) < std::max(distanceSquared, vetoDistanceSquared))
             {
                 replacementVeto = true;
                 break;
             }
         }
 
         if (branchVeto || replacementVeto)
             continue;
 
         outputList.push_back(thisSplit);
     }
 }

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

protectedvirtual

Reimplemented in lar_content::BranchSplittingAlgorithm, and lar_content::DeltaRaySplittingAlgorithm.

Definition at line 422 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ShortHalfWindow", m_shortHalfWindowLayers));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "LongHalfWindow", m_longHalfWindowLayers));
 
     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, "VetoDisplacement", m_vetoDisplacement));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CosmicMode", m_runCosmicMode));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::ReplaceBranch	(	const pandora::Cluster *const	pBranchCluster,
		const pandora::Cluster *const	pReplacementCluster,
		const pandora::CartesianVector &	branchSplitPosition,
		const pandora::CartesianVector &	branchSplitDirection
	)		const

private

Remove a branch from a cluster and replace it with a second cluster.

Parameters

pBranchCluster	the cluster containing a branch to be removed
pReplacementCluster	the replacement cluster
branchSplitPosition	the position at the start of the branch
branchSplitDirection	the direction at the start of the branch

Definition at line 392 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.cc.

 {
     ClusterList clusterList;
     clusterList.push_back(pBranchCluster);
     clusterList.push_back(pReplacementCluster);
 
     std::string clusterListToSaveName, clusterListToDeleteName;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         PandoraContentApi::InitializeFragmentation(*this, clusterList, clusterListToDeleteName, clusterListToSaveName));
 
     // Entire replacement cluster goes into new principal cluster
     PandoraContentApi::Cluster::Parameters principalParameters;
     pReplacementCluster->GetOrderedCaloHitList().FillCaloHitList(principalParameters.m_caloHitList);
 
     // Distribute hits in branch cluster between new principal and residual clusters
     PandoraContentApi::Cluster::Parameters residualParameters;
     this->SplitBranchCluster(
         pBranchCluster, branchSplitPosition, branchSplitDirection, principalParameters.m_caloHitList, residualParameters.m_caloHitList);
 
     const Cluster *pPrincipalCluster(NULL), *pResidualCluster(NULL);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, principalParameters, pPrincipalCluster));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, residualParameters, pResidualCluster));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, clusterListToSaveName, clusterListToDeleteName));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::Run ( )

protectedvirtual

Definition at line 32 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.cc.

 {
     const ClusterList *pClusterList = NULL;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pClusterList));
 
     TwoDSlidingFitResultMap branchSlidingFitResultMap, replacementSlidingFitResultMap;
 
     unsigned int nIterations(0);
 
     while (++nIterations < 100) // Protect against flip-flopping between two answers
     {
         // Get ordered list of candidate clusters
         ClusterVector clusterVector;
         this->GetListOfCleanClusters(pClusterList, clusterVector);
 
         // Calculate sliding fit results for branch clusters (use a soft sliding fit for these)
         this->BuildSlidingFitResultMap(clusterVector, m_shortHalfWindowLayers, branchSlidingFitResultMap);
 
         // Calculate sliding fit results for replacement clusters (use a hard linear fit for these)
         this->BuildSlidingFitResultMap(clusterVector, m_longHalfWindowLayers, replacementSlidingFitResultMap);
 
         // Compile a list of possible splits
         ClusterExtensionList splitList;
 
         if (m_runCosmicMode)
         {
             this->BuildClusterExtensionList(clusterVector, branchSlidingFitResultMap, replacementSlidingFitResultMap, splitList);
         }
         else
         {
             ClusterExtensionList intermediateList;
             this->BuildClusterExtensionList(clusterVector, branchSlidingFitResultMap, replacementSlidingFitResultMap, intermediateList);
             this->PruneClusterExtensionList(intermediateList, branchSlidingFitResultMap, replacementSlidingFitResultMap, splitList);
         }
 
         // Run splitting and extension
         if (STATUS_CODE_SUCCESS != this->RunSplitAndExtension(splitList, branchSlidingFitResultMap, replacementSlidingFitResultMap))
             break;
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::RunSplitAndExtension	(	const ClusterExtensionList &	splitList,
		TwoDSlidingFitResultMap &	branchResultMap,
		TwoDSlidingFitResultMap &	replacementResultMap
	)		const

private

Run the machinary that performs the cluster splitting and extending.

Parameters

splitList	the input list of candidate splits
branchResultMap	the sliding fit result map for branch clusters
replacementResultMap	the sliding fit result map for replacement clusters

Definition at line 349 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.cc.

 {
     bool foundSplit(false);
 
     for (ClusterExtensionList::const_iterator iter = splitList.begin(), iterEnd = splitList.end(); iter != iterEnd; ++iter)
     {
         const ClusterExtension &thisSplit = *iter;
 
         const Cluster *const pBranchCluster = thisSplit.GetBranchCluster();
         const Cluster *const pReplacementCluster = thisSplit.GetReplacementCluster();
         const CartesianVector &branchSplitPosition = thisSplit.GetBranchVertex();
         const CartesianVector &branchSplitDirection = thisSplit.GetBranchDirection();
 
         TwoDSlidingFitResultMap::iterator iterBranch1 = branchResultMap.find(pBranchCluster);
         TwoDSlidingFitResultMap::iterator iterBranch2 = branchResultMap.find(pReplacementCluster);
 
         TwoDSlidingFitResultMap::iterator iterReplacement1 = replacementResultMap.find(pBranchCluster);
         TwoDSlidingFitResultMap::iterator iterReplacement2 = replacementResultMap.find(pReplacementCluster);
 
         if (branchResultMap.end() == iterBranch1 || branchResultMap.end() == iterBranch2 ||
             replacementResultMap.end() == iterReplacement1 || replacementResultMap.end() == iterReplacement2)
             continue;
 
         PANDORA_RETURN_RESULT_IF(
             STATUS_CODE_SUCCESS, !=, this->ReplaceBranch(pBranchCluster, pReplacementCluster, branchSplitPosition, branchSplitDirection));
         branchResultMap.erase(iterBranch1);
         branchResultMap.erase(iterBranch2);
 
         replacementResultMap.erase(iterReplacement1);
         replacementResultMap.erase(iterReplacement2);
 
         foundSplit = true;
     }
 
     if (foundSplit)
         return STATUS_CODE_SUCCESS;
 
     return STATUS_CODE_NOT_FOUND;
 }

void lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::SplitBranchCluster	(	const pandora::Cluster *const	pCluster,
		const pandora::CartesianVector &	splitPosition,
		const pandora::CartesianVector &	splitDirection,
		pandora::CaloHitList &	principalCaloHitList,
		pandora::CaloHitList &	branchCaloHitList
	)		const

private

Separate cluster into the branch hits to be split from the primary cluster.

Parameters

pCluster	the input branch cluster
splitPosition	the start position of the branch
splitDirection	the start direction of the branch
principalCaloHitList	the hits to be added to the principal cluster
branchCaloHitList	the hits to be split off into the output branch cluster

Definition at line 322 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.cc.

 {
     // Distribute hits in branch cluster between new principal and residual clusters
     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)
         {
             branchCaloHitList.push_back(pCaloHit);
         }
         else
         {
             principalCaloHitList.push_back(pCaloHit);
         }
     }
 
     if (branchCaloHitList.empty())
         throw StatusCodeException(STATUS_CODE_NOT_ALLOWED);
 }