#include <BranchSplittingAlgorithm.h>

Inheritance diagram for lar_content::BranchSplittingAlgorithm:

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

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

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

Additional Inherited Members
Protected Types inherited from lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm
typedef std::vector < ClusterExtension >	ClusterExtensionList

Protected Member Functions inherited from lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm
virtual pandora::StatusCode	Run ()

Detailed Description

BranchSplittingAlgorithm class.

Definition at line 19 of file BranchSplittingAlgorithm.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.

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

Member Data Documentation

float lar_content::BranchSplittingAlgorithm::m_maxLongitudinalDisplacement

private

Definition at line 35 of file BranchSplittingAlgorithm.h.

float lar_content::BranchSplittingAlgorithm::m_maxTransverseDisplacement

private

Definition at line 34 of file BranchSplittingAlgorithm.h.

float lar_content::BranchSplittingAlgorithm::m_minCosRelativeAngle

private

Definition at line 37 of file BranchSplittingAlgorithm.h.

float lar_content::BranchSplittingAlgorithm::m_minLongitudinalExtension

private

Definition at line 36 of file BranchSplittingAlgorithm.h.

float lar_content::BranchSplittingAlgorithm::m_projectionAngularAllowance

private

Definition at line 38 of file BranchSplittingAlgorithm.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation