#include "BranchSplittingAlgorithm.h"

Inheritance diagram for lar_content::BranchSplittingAlgorithm:

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

Protected Types
typedef std::vector< ClusterExtension >	ClusterExtensionList

Protected Member Functions
virtual pandora::StatusCode	Run ()

Private Member Functions
void	FindBestSplitPosition (const TwoDSlidingFitResult &branchSlidingFit, const TwoDSlidingFitResult &replacementSlidingFit, pandora::CartesianVector &replacementStartPosition, pandora::CartesianVector &branchSplitPosition, pandora::CartesianVector &branchSplitDirection) const
	Output the best split positions in branch and replacement clusters. More...

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

Private Attributes
float	m_maxTransverseDisplacement

float	m_maxLongitudinalDisplacement

float	m_minLongitudinalExtension

float	m_minCosRelativeAngle

float	m_projectionAngularAllowance

Detailed Description

BranchSplittingAlgorithm class.

Definition at line 19 of file BranchSplittingAlgorithm.h.

Member Typedef Documentation

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

protectedinherited

Definition at line 85 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::BranchSplittingAlgorithm::BranchSplittingAlgorithm ( )

Default constructor.

Definition at line 20 of file BranchSplittingAlgorithm.cc.

                                                    :
     m_maxTransverseDisplacement(1.5f),
     m_maxLongitudinalDisplacement(10.f),
     m_minLongitudinalExtension(3.f),
     m_minCosRelativeAngle(0.966f),
     m_projectionAngularAllowance(20.f)
 {
 }

Member Function Documentation

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

privatevirtual

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

Implements lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm.

Definition at line 31 of file BranchSplittingAlgorithm.cc.

 {
     // Conventions:
     // (1) Delta ray is split from the branch cluster
     // (2) Delta ray occurs where the vertex of the principal cluster meets the vertex of the branch cluster
     //     Method loops over the inner and outer positions of the principal and branch clusters, trying all
     //     possible assignments of vertex and end position until a split is found
     for (unsigned int principalForward = 0; principalForward < 2; ++principalForward)
     {
         const CartesianVector principalVertexPosition(
             1 == principalForward ? principalSlidingFit.GetGlobalMinLayerPosition() : principalSlidingFit.GetGlobalMaxLayerPosition());
         const CartesianVector principalEndPosition(
             1 != principalForward ? principalSlidingFit.GetGlobalMinLayerPosition() : principalSlidingFit.GetGlobalMaxLayerPosition());
         const CartesianVector principalVertexDirection(1 == principalForward ? principalSlidingFit.GetGlobalMinLayerDirection()
                                                                              : principalSlidingFit.GetGlobalMaxLayerDirection() * -1.f);
 
         CartesianVector projectedBranchPosition(0.f, 0.f, 0.f);
         bool projectedPositionFound(false), projectedPositionFail(false);
 
         for (unsigned int branchForward = 0; branchForward < 2; ++branchForward)
         {
             const CartesianVector branchVertexPosition(
                 1 == branchForward ? branchSlidingFit.GetGlobalMinLayerPosition() : branchSlidingFit.GetGlobalMaxLayerPosition());
             const CartesianVector branchEndPosition(
                 1 != branchForward ? branchSlidingFit.GetGlobalMinLayerPosition() : branchSlidingFit.GetGlobalMaxLayerPosition());
             const CartesianVector branchEndDirection(
                 1 != branchForward ? branchSlidingFit.GetGlobalMinLayerDirection() : branchSlidingFit.GetGlobalMaxLayerDirection() * -1.f);
 
             if (principalVertexDirection.GetDotProduct(branchEndDirection) < 0.5f)
                 continue;
 
             if ((principalEndPosition - branchEndPosition).GetMagnitudeSquared() < (principalVertexPosition - branchVertexPosition).GetMagnitudeSquared())
                 continue;
 
             // Project the principal vertex onto the branch cluster
             try
             {
                 if (!projectedPositionFound && !projectedPositionFail)
                 {
                     projectedBranchPosition = LArPointingClusterHelper::GetProjectedPosition(
                         principalVertexPosition, principalVertexDirection, branchSlidingFit.GetCluster(), m_projectionAngularAllowance);
                     projectedPositionFound = true;
                 }
             }
             catch (StatusCodeException &)
             {
                 projectedPositionFail = true;
             }
 
             if (!projectedPositionFound || projectedPositionFail)
                 continue;
 
             const float projectedDistanceSquared((projectedBranchPosition - principalVertexPosition).GetMagnitudeSquared());
 
             if (projectedDistanceSquared > m_maxLongitudinalDisplacement * m_maxLongitudinalDisplacement)
                 continue;
 
             const float commonDistanceSquared((projectedBranchPosition - branchEndPosition).GetMagnitudeSquared());
 
             if (projectedDistanceSquared > commonDistanceSquared)
                 continue;
 
             const float replacementDistanceSquared((projectedBranchPosition - principalEndPosition).GetMagnitudeSquared());
 
             if (replacementDistanceSquared < m_minLongitudinalExtension * m_minLongitudinalExtension)
                 continue;
 
             const float branchDistanceSquared((projectedBranchPosition - branchVertexPosition).GetMagnitudeSquared());
 
             if (branchDistanceSquared > 4.f * replacementDistanceSquared)
                 continue;
 
             // Require that principal vertex and branch projection have good (and improved) pointing
             bool foundSplit(false);
 
             const float halfWindowLength(branchSlidingFit.GetLayerFitHalfWindowLength());
             const float deltaL(1 == branchForward ? +halfWindowLength : -halfWindowLength);
 
             float localL(0.f), localT(0.f);
             CartesianVector forwardDirection(0.f, 0.f, 0.f);
             branchSlidingFit.GetLocalPosition(projectedBranchPosition, localL, localT);
 
             if (STATUS_CODE_SUCCESS != branchSlidingFit.GetGlobalFitDirection(localL + deltaL, forwardDirection))
                 continue;
 
             CartesianVector projectedBranchDirection(1 == branchForward ? forwardDirection : forwardDirection * -1.f);
             const float cosTheta(-projectedBranchDirection.GetDotProduct(principalVertexDirection));
 
             try
             {
                 const float currentCosTheta(branchSlidingFit.GetCosScatteringAngle(localL));
 
                 if (cosTheta < currentCosTheta)
                     continue;
             }
             catch (StatusCodeException &)
             {
             }
 
             float rT1(0.f), rL1(0.f), rT2(0.f), rL2(0.f);
             LArPointingClusterHelper::GetImpactParameters(projectedBranchPosition, projectedBranchDirection, principalVertexPosition, rL1, rT1);
             LArPointingClusterHelper::GetImpactParameters(principalVertexPosition, principalVertexDirection, projectedBranchPosition, rL2, rT2);
 
             if ((cosTheta > m_minCosRelativeAngle) && (rT1 < m_maxTransverseDisplacement) && (rT2 < m_maxTransverseDisplacement))
             {
                 foundSplit = true;
                 principalStartPosition = principalVertexPosition;
                 branchSplitPosition = projectedBranchPosition;
                 branchSplitDirection = projectedBranchDirection * -1.f;
             }
 
             if (foundSplit)
                 return;
         }
     }
 
     throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 }

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

privatevirtual

Reimplemented from lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm.

Definition at line 153 of file BranchSplittingAlgorithm.cc.

References m_maxLongitudinalDisplacement, m_maxTransverseDisplacement, m_minCosRelativeAngle, m_minLongitudinalExtension, m_projectionAngularAllowance, and lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::ReadSettings().

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxTransverseDisplacement", m_maxTransverseDisplacement));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxLongitudinalDisplacement", m_maxLongitudinalDisplacement));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinLongitudinalExtension", m_minLongitudinalExtension));
 
     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, "ProjectionAngularAllowance", m_projectionAngularAllowance));
 
     return TwoDSlidingFitSplittingAndSplicingAlgorithm::ReadSettings(xmlHandle);
 }

StatusCode lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::Run ( )

protectedvirtualinherited

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;
 }

Member Data Documentation

float lar_content::BranchSplittingAlgorithm::m_maxLongitudinalDisplacement

private

Definition at line 35 of file BranchSplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

float lar_content::BranchSplittingAlgorithm::m_maxTransverseDisplacement

private

Definition at line 34 of file BranchSplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

float lar_content::BranchSplittingAlgorithm::m_minCosRelativeAngle

private

Definition at line 37 of file BranchSplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

float lar_content::BranchSplittingAlgorithm::m_minLongitudinalExtension

private

Definition at line 36 of file BranchSplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

float lar_content::BranchSplittingAlgorithm::m_projectionAngularAllowance

private

Definition at line 38 of file BranchSplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

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

larpandoracontent/v04_08_01/source/larpandoracontent/LArTwoDReco/LArClusterSplitting/BranchSplittingAlgorithm.h
larpandoracontent/v04_08_01/source/larpandoracontent/LArTwoDReco/LArClusterSplitting/BranchSplittingAlgorithm.cc

Public Member Functions

Protected Types

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation