CandidateVertexCreationAlgorithm::Algorithm class. More...

#include "CandidateVertexCreationAlgorithm.h"

Inheritance diagram for lar_content::CandidateVertexCreationAlgorithm:

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

Private Types
typedef std::unordered_map< const pandora::Cluster *, pandora::CartesianPointVector >	ClusterToSpacepointsMap

Private Member Functions
pandora::StatusCode	Run ()

void	SelectClusters (pandora::ClusterVector &clusterVectorU, pandora::ClusterVector &clusterVectorV, pandora::ClusterVector &clusterVectorW)
	Select a subset of input clusters (contained in the input list names) for processing in this algorithm. More...

void	CreateEndpointCandidates (const pandora::ClusterVector &clusterVector1, const pandora::ClusterVector &clusterVector2) const
	Create candidate vertex positions by comparing pairs of cluster end positions. More...

void	CreateEndpointVertex (const pandora::CartesianVector &position1, const pandora::HitType hitType1, const TwoDSlidingFitResult &fitResult2) const
	Create a candidate vertex position, using an end-point position from one cluster and sliding fit to a second cluster. More...

void	CreateCrossingCandidates (const pandora::ClusterVector &clusterVectorU, const pandora::ClusterVector &clusterVectorV, const pandora::ClusterVector &clusterVectorW) const
	Extrapolate 2D clusters, find where they cross, and match crossing points between views to create vertex candidates. More...

void	FindCrossingPoints (const pandora::ClusterVector &clusterVector, pandora::CartesianPointVector &crossingPoints) const
	Identify where (extrapolated) clusters plausibly cross in 2D. More...

void	GetSpacepoints (const pandora::Cluster *const pCluster, pandora::CartesianPointVector &spacePoints) const
	Get a list of spacepoints representing cluster 2D hit positions and extrapolated positions. More...

void	FindCrossingPoints (const pandora::CartesianPointVector &spacepoints1, const pandora::CartesianPointVector &spacepoints2, pandora::CartesianPointVector &crossingPoints) const
	Identify where (extrapolated) clusters plausibly cross in 2D. More...

void	CreateCrossingVertices (const pandora::CartesianPointVector &crossingPoints1, const pandora::CartesianPointVector &crossingPoints2, const pandora::HitType hitType1, const pandora::HitType hitType2, unsigned int &nCrossingCandidates) const
	Attempt to create candidate vertex positions, using 2D crossing points in 2 views. More...

void	AddInputVertices () const
	Add candidate vertices from any input vertices. More...

void	AddToSlidingFitCache (const pandora::Cluster *const pCluster)
	Creates a 2D sliding fit of a cluster and stores it for later use. More...

const TwoDSlidingFitResult &	GetCachedSlidingFitResult (const pandora::Cluster *const pCluster) const
	Get a sliding fit result from the algorithm cache. More...

void	TidyUp ()
	Clear relevant algorithm member variables between events. More...

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

Private Attributes
pandora::StringVector	m_inputClusterListNames
	The list of cluster list names. More...

std::string	m_inputVertexListName
	The list name for existing candidate vertices. More...

std::string	m_outputVertexListName
	The name under which to save the output vertex list. More...

bool	m_replaceCurrentVertexList
	Whether to replace the current vertex list with the output list. More...

unsigned int	m_slidingFitWindow
	The layer window for the sliding linear fits. More...

TwoDSlidingFitResultMap	m_slidingFitResultMap
	The sliding fit result map. More...

unsigned int	m_minClusterCaloHits
	The min number of hits in base cluster selection method. More...

float	m_minClusterLengthSquared
	The min length (squared) in base cluster selection method. More...

float	m_chiSquaredCut
	The chi squared cut (accept only 3D vertex positions with values below cut) More...

bool	m_enableEndpointCandidates
	Whether to create endpoint-based candidates. More...

float	m_maxEndpointXDiscrepancy
	The max cluster endpoint discrepancy. More...

bool	m_enableCrossingCandidates
	Whether to create crossing vertex candidates. More...

unsigned int	m_nMaxCrossingCandidates
	The max number of crossing candidates to create. More...

float	m_maxCrossingXDiscrepancy
	The max cluster endpoint discrepancy. More...

unsigned int	m_extrapolationNSteps
	Number of extrapolation steps, at each end of cluster, of specified size. More...

float	m_extrapolationStepSize
	The extrapolation step size in cm. More...

float	m_maxCrossingSeparationSquared
	The separation (squared) between spacepoints below which a crossing can be identified. More...

float	m_minNearbyCrossingDistanceSquared
	The minimum allowed distance between identified crossing positions. More...

bool	m_reducedCandidates
	Whether to reduce the number of candidates. More...

float	m_selectionCutFactorMax
	Maximum factor to multiply the base cluster selection cuts. More...

float	m_nClustersPassingMaxCutsPar
	Parameter for number of clusters passing the max base cluster selection cuts. More...

Detailed Description

CandidateVertexCreationAlgorithm::Algorithm class.

Definition at line 23 of file CandidateVertexCreationAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, pandora::CartesianPointVector> lar_content::CandidateVertexCreationAlgorithm::ClusterToSpacepointsMap

private

Definition at line 134 of file CandidateVertexCreationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::CandidateVertexCreationAlgorithm::CandidateVertexCreationAlgorithm ( )

Default constructor.

Definition at line 23 of file CandidateVertexCreationAlgorithm.cc.

                                                                    :
     m_replaceCurrentVertexList(true),
     m_slidingFitWindow(20),
     m_minClusterCaloHits(5),
     m_minClusterLengthSquared(3.f * 3.f),
     m_chiSquaredCut(2.f),
     m_enableEndpointCandidates(true),
     m_maxEndpointXDiscrepancy(4.f),
     m_enableCrossingCandidates(false),
     m_nMaxCrossingCandidates(500),
     m_maxCrossingXDiscrepancy(0.5f),
     m_extrapolationNSteps(200),
     m_extrapolationStepSize(0.1f),
     m_maxCrossingSeparationSquared(2.f * 2.f),
     m_minNearbyCrossingDistanceSquared(0.5f * 0.5f),
     m_reducedCandidates(false),
     m_selectionCutFactorMax(2.f),
     m_nClustersPassingMaxCutsPar(26.f)
 {
 }

Member Function Documentation

void lar_content::CandidateVertexCreationAlgorithm::AddInputVertices ( ) const

private

Add candidate vertices from any input vertices.

Definition at line 398 of file CandidateVertexCreationAlgorithm.cc.

References m_inputVertexListName.

Referenced by Run().

 {
     const VertexList *pInputVertexList{nullptr};
     try
     { // ATTN - No guarantee the list has been initialised, but silent failure here is ok
         PandoraContentApi::GetList(*this, m_inputVertexListName, pInputVertexList);
         if (!pInputVertexList)
             return;
 
         for (const Vertex *pInputVertex : *pInputVertexList)
         {
             PandoraContentApi::Vertex::Parameters parameters;
             parameters.m_position = pInputVertex->GetPosition();
             parameters.m_vertexLabel = VERTEX_INTERACTION;
             parameters.m_vertexType = VERTEX_3D;
 
             const Vertex *pVertex(nullptr);
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*this, parameters, pVertex));
         }
     }
     catch (const StatusCodeException &)
     {
         return;
     }
 }

void lar_content::CandidateVertexCreationAlgorithm::AddToSlidingFitCache ( const pandora::Cluster *const pCluster )

private

Creates a 2D sliding fit of a cluster and stores it for later use.

Parameters

pCluster address of the relevant cluster

Definition at line 426 of file CandidateVertexCreationAlgorithm.cc.

References lar_content::LArGeometryHelper::GetWireZPitch(), m_slidingFitResultMap, and m_slidingFitWindow.

Referenced by SelectClusters().

 {
     const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
     const TwoDSlidingFitResult slidingFitResult(pCluster, m_slidingFitWindow, slidingFitPitch);
 
     if (!m_slidingFitResultMap.insert(TwoDSlidingFitResultMap::value_type(pCluster, slidingFitResult)).second)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 }

void lar_content::CandidateVertexCreationAlgorithm::CreateCrossingCandidates	(	const pandora::ClusterVector &	clusterVectorU,
		const pandora::ClusterVector &	clusterVectorV,
		const pandora::ClusterVector &	clusterVectorW
	)		const

private

Extrapolate 2D clusters, find where they cross, and match crossing points between views to create vertex candidates.

Parameters

clusterVectorU	the clusters in the u view
clusterVectorV	the clusters in the v view
clusterVectorW	the clusters in the w view

Definition at line 251 of file CandidateVertexCreationAlgorithm.cc.

References CreateCrossingVertices(), FindCrossingPoints(), and GetSpacepoints().

Referenced by Run().

 {
     CartesianPointVector crossingsU, crossingsV, crossingsW;
     this->FindCrossingPoints(clusterVectorU, crossingsU);
     this->FindCrossingPoints(clusterVectorV, crossingsV);
     this->FindCrossingPoints(clusterVectorW, crossingsW);
 
     unsigned int nCrossingCandidates(0);
     this->CreateCrossingVertices(crossingsU, crossingsV, TPC_VIEW_U, TPC_VIEW_V, nCrossingCandidates);
     this->CreateCrossingVertices(crossingsU, crossingsW, TPC_VIEW_U, TPC_VIEW_W, nCrossingCandidates);
     this->CreateCrossingVertices(crossingsV, crossingsW, TPC_VIEW_V, TPC_VIEW_W, nCrossingCandidates);
 }

void lar_content::CandidateVertexCreationAlgorithm::CreateCrossingVertices	(	const pandora::CartesianPointVector &	crossingPoints1,
		const pandora::CartesianPointVector &	crossingPoints2,
		const pandora::HitType	hitType1,
		const pandora::HitType	hitType2,
		unsigned int &	nCrossingCandidates
	)		const

private

Attempt to create candidate vertex positions, using 2D crossing points in 2 views.

Parameters

crossingPoints1	the crossing points in view 1
crossingPoints2	the crossing points in view 2
hitType1	the hit type of crossing points 1
hitType2	the hit type of crossing points 2
nCrossingCandidates	to count the number of crossing candidates created

Definition at line 363 of file CandidateVertexCreationAlgorithm.cc.

References f, m_chiSquaredCut, m_maxCrossingXDiscrepancy, m_nMaxCrossingCandidates, and lar_content::LArGeometryHelper::MergeTwoPositions3D().

Referenced by CreateCrossingCandidates().

 {
 
     for (const CartesianVector &position1 : crossingPoints1)
     {
         for (const CartesianVector &position2 : crossingPoints2)
         {
             if (nCrossingCandidates > m_nMaxCrossingCandidates)
                 return;
 
             if (std::fabs(position1.GetX() - position2.GetX()) > m_maxCrossingXDiscrepancy)
                 continue;
 
             float chiSquared(0.f);
             CartesianVector position3D(0.f, 0.f, 0.f);
             LArGeometryHelper::MergeTwoPositions3D(this->GetPandora(), hitType1, hitType2, position1, position2, position3D, chiSquared);
 
             if (chiSquared > m_chiSquaredCut)
                 continue;
 
             PandoraContentApi::Vertex::Parameters parameters;
             parameters.m_position = position3D;
             parameters.m_vertexLabel = VERTEX_INTERACTION;
             parameters.m_vertexType = VERTEX_3D;
 
             const Vertex *pVertex(NULL);
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*this, parameters, pVertex));
             ++nCrossingCandidates;
         }
     }
 }

void lar_content::CandidateVertexCreationAlgorithm::CreateEndpointCandidates	(	const pandora::ClusterVector &	clusterVector1,
		const pandora::ClusterVector &	clusterVector2
	)		const

private

Create candidate vertex positions by comparing pairs of cluster end positions.

Parameters

clusterVector1	the clusters in view 1
clusterVector1	the clusters in view 2

Definition at line 185 of file CandidateVertexCreationAlgorithm.cc.

References CreateEndpointVertex(), GetCachedSlidingFitResult(), lar_content::LArClusterHelper::GetClusterHitType(), lar_content::TwoDSlidingFitResult::GetGlobalMaxLayerPosition(), and lar_content::TwoDSlidingFitResult::GetGlobalMinLayerPosition().

Referenced by Run().

 {
     for (const Cluster *const pCluster1 : clusterVector1)
     {
         const HitType hitType1(LArClusterHelper::GetClusterHitType(pCluster1));
 
         const TwoDSlidingFitResult &fitResult1(this->GetCachedSlidingFitResult(pCluster1));
         const CartesianVector minLayerPosition1(fitResult1.GetGlobalMinLayerPosition());
         const CartesianVector maxLayerPosition1(fitResult1.GetGlobalMaxLayerPosition());
 
         for (const Cluster *const pCluster2 : clusterVector2)
         {
             const HitType hitType2(LArClusterHelper::GetClusterHitType(pCluster2));
 
             const TwoDSlidingFitResult &fitResult2(this->GetCachedSlidingFitResult(pCluster2));
             const CartesianVector minLayerPosition2(fitResult2.GetGlobalMinLayerPosition());
             const CartesianVector maxLayerPosition2(fitResult2.GetGlobalMaxLayerPosition());
 
             this->CreateEndpointVertex(maxLayerPosition1, hitType1, fitResult2);
             this->CreateEndpointVertex(minLayerPosition1, hitType1, fitResult2);
             this->CreateEndpointVertex(maxLayerPosition2, hitType2, fitResult1);
             this->CreateEndpointVertex(minLayerPosition2, hitType2, fitResult1);
         }
     }
 }

void lar_content::CandidateVertexCreationAlgorithm::CreateEndpointVertex	(	const pandora::CartesianVector &	position1,
		const pandora::HitType	hitType1,
		const TwoDSlidingFitResult &	fitResult2
	)		const

private

Create a candidate vertex position, using an end-point position from one cluster and sliding fit to a second cluster.

Parameters

position1	an end-point position for the first cluster
hitType1	the hit type of the first cluster
fitResult2	the two dimensional sliding fit result for the second cluster

Definition at line 213 of file CandidateVertexCreationAlgorithm.cc.

References f, lar_content::TwoDSlidingFitResult::GetCluster(), lar_content::LArClusterHelper::GetClusterHitType(), lar_content::TwoDSlidingFitResult::GetExtrapolatedPositionAtX(), lar_content::TwoDSlidingFitResult::GetGlobalMaxLayerPosition(), lar_content::TwoDSlidingFitResult::GetGlobalMinLayerPosition(), m_chiSquaredCut, m_maxEndpointXDiscrepancy, and lar_content::LArGeometryHelper::MergeTwoPositions3D().

Referenced by CreateEndpointCandidates().

 {
     const CartesianVector minLayerPosition2(fitResult2.GetGlobalMinLayerPosition());
     const CartesianVector maxLayerPosition2(fitResult2.GetGlobalMaxLayerPosition());
 
     if ((((position1.GetX() < minLayerPosition2.GetX()) && (position1.GetX() < maxLayerPosition2.GetX())) ||
             ((position1.GetX() > minLayerPosition2.GetX()) && (position1.GetX() > maxLayerPosition2.GetX()))) &&
         (std::fabs(position1.GetX() - minLayerPosition2.GetX()) > m_maxEndpointXDiscrepancy) &&
         (std::fabs(position1.GetX() - maxLayerPosition2.GetX()) > m_maxEndpointXDiscrepancy))
     {
         return;
     }
 
     CartesianVector position2(0.f, 0.f, 0.f);
     if (STATUS_CODE_SUCCESS != fitResult2.GetExtrapolatedPositionAtX(position1.GetX(), position2))
         return;
 
     const HitType hitType2(LArClusterHelper::GetClusterHitType(fitResult2.GetCluster()));
 
     float chiSquared(0.f);
     CartesianVector position3D(0.f, 0.f, 0.f);
     LArGeometryHelper::MergeTwoPositions3D(this->GetPandora(), hitType1, hitType2, position1, position2, position3D, chiSquared);
 
     if (chiSquared > m_chiSquaredCut)
         return;
 
     PandoraContentApi::Vertex::Parameters parameters;
     parameters.m_position = position3D;
     parameters.m_vertexLabel = VERTEX_INTERACTION;
     parameters.m_vertexType = VERTEX_3D;
 
     const Vertex *pVertex(NULL);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*this, parameters, pVertex));
 }

void lar_content::CandidateVertexCreationAlgorithm::FindCrossingPoints	(	const pandora::ClusterVector &	clusterVector,
		pandora::CartesianPointVector &	crossingPoints
	)		const

private

Identify where (extrapolated) clusters plausibly cross in 2D.

Parameters

clusterVector	the input clusters
crossingPoints	to receive the 2D crossing points

Referenced by CreateCrossingCandidates(), and GetSpacepoints().

void lar_content::CandidateVertexCreationAlgorithm::FindCrossingPoints	(	const pandora::CartesianPointVector &	spacepoints1,
		const pandora::CartesianPointVector &	spacepoints2,
		pandora::CartesianPointVector &	crossingPoints
	)		const

private

Identify where (extrapolated) clusters plausibly cross in 2D.

Parameters

spacepoints1	space points for cluster 1
spacepoints2	space points for cluster 2
crossingPoints	to receive the list of plausible 2D crossing points

const TwoDSlidingFitResult & lar_content::CandidateVertexCreationAlgorithm::GetCachedSlidingFitResult ( const pandora::Cluster *const pCluster ) const

private

Get a sliding fit result from the algorithm cache.

Parameters

pCluster address of the relevant cluster

Definition at line 437 of file CandidateVertexCreationAlgorithm.cc.

References m_slidingFitResultMap.

Referenced by CreateEndpointCandidates(), and GetSpacepoints().

 {
     TwoDSlidingFitResultMap::const_iterator iter = m_slidingFitResultMap.find(pCluster);
 
     if (m_slidingFitResultMap.end() == iter)
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     return iter->second;
 }

void lar_content::CandidateVertexCreationAlgorithm::GetSpacepoints	(	const pandora::Cluster *const	pCluster,
		pandora::CartesianPointVector &	spacePoints
	)		const

private

Get a list of spacepoints representing cluster 2D hit positions and extrapolated positions.

Parameters

pCluster	address of the cluster
spacePoints	to receive the list of spacepoints

Definition at line 291 of file CandidateVertexCreationAlgorithm.cc.

References f, FindCrossingPoints(), GetCachedSlidingFitResult(), lar_content::LArClusterHelper::GetCoordinateVector(), lar_content::TwoDSlidingFitResult::GetExtrapolatedPosition(), lar_content::TwoDSlidingFitResult::GetL(), lar_content::TwoDSlidingFitResult::GetMaxLayer(), lar_content::TwoDSlidingFitResult::GetMinLayer(), m_extrapolationNSteps, m_extrapolationStepSize, m_maxCrossingSeparationSquared, m_minNearbyCrossingDistanceSquared, and lar_content::LArClusterHelper::SortCoordinatesByPosition().

Referenced by CreateCrossingCandidates().

 {
     LArClusterHelper::GetCoordinateVector(pCluster, spacepoints);
 
     const TwoDSlidingFitResult &fitResult(this->GetCachedSlidingFitResult(pCluster));
     const float minLayerRL(fitResult.GetL(fitResult.GetMinLayer()));
     const float maxLayerRL(fitResult.GetL(fitResult.GetMaxLayer()));
 
     for (unsigned int iStep = 0; iStep < m_extrapolationNSteps; ++iStep)
     {
         const float deltaRL(static_cast<float>(iStep) * m_extrapolationStepSize);
 
         CartesianVector positionPositive(0.f, 0.f, 0.f), positionNegative(0.f, 0.f, 0.f);
         fitResult.GetExtrapolatedPosition(maxLayerRL + deltaRL, positionPositive);
         fitResult.GetExtrapolatedPosition(minLayerRL - deltaRL, positionNegative);
 
         spacepoints.push_back(positionPositive);
         spacepoints.push_back(positionNegative);
     }
 
     std::sort(spacepoints.begin(), spacepoints.end(), LArClusterHelper::SortCoordinatesByPosition);
 }

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

private

Definition at line 456 of file CandidateVertexCreationAlgorithm.cc.

References m_chiSquaredCut, m_enableCrossingCandidates, m_enableEndpointCandidates, m_extrapolationNSteps, m_extrapolationStepSize, m_inputClusterListNames, m_inputVertexListName, m_maxCrossingSeparationSquared, m_maxCrossingXDiscrepancy, m_maxEndpointXDiscrepancy, m_minClusterCaloHits, m_minClusterLengthSquared, m_minNearbyCrossingDistanceSquared, m_nClustersPassingMaxCutsPar, m_nMaxCrossingCandidates, m_outputVertexListName, m_reducedCandidates, m_replaceCurrentVertexList, m_selectionCutFactorMax, and m_slidingFitWindow.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "InputClusterListNames", m_inputClusterListNames));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "InputVertexListName", m_inputVertexListName));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputVertexListName", m_outputVertexListName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ReplaceCurrentVertexList", m_replaceCurrentVertexList));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitWindow", m_slidingFitWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterCaloHits", m_minClusterCaloHits));
 
     float minClusterLength = std::sqrt(m_minClusterLengthSquared);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterLength", minClusterLength));
     m_minClusterLengthSquared = minClusterLength * minClusterLength;
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ChiSquaredCut", m_chiSquaredCut));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "EnableEndpointCandidates", m_enableEndpointCandidates));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxEndpointXDiscrepancy", m_maxEndpointXDiscrepancy));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "EnableCrossingCandidates", m_enableCrossingCandidates));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NMaxCrossingCandidates", m_nMaxCrossingCandidates));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxCrossingXDiscrepancy", m_maxCrossingXDiscrepancy));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ExtrapolationNSteps", m_extrapolationNSteps));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ExtrapolationStepSize", m_extrapolationStepSize));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ReducedCandidates", m_reducedCandidates));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SelectionCutFactorMax", m_selectionCutFactorMax));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "NClustersPassingMaxCutsPar", m_nClustersPassingMaxCutsPar));
 
     float maxCrossingSeparation = std::sqrt(m_maxCrossingSeparationSquared);
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxCrossingSeparation", maxCrossingSeparation));
     m_maxCrossingSeparationSquared = maxCrossingSeparation * maxCrossingSeparation;
 
     float minNearbyCrossingDistance = std::sqrt(m_minNearbyCrossingDistanceSquared);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinNearbyCrossingDistance", minNearbyCrossingDistance));
     m_minNearbyCrossingDistanceSquared = minNearbyCrossingDistance * minNearbyCrossingDistance;
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::CandidateVertexCreationAlgorithm::Run ( )

private

Definition at line 46 of file CandidateVertexCreationAlgorithm.cc.

References AddInputVertices(), CreateCrossingCandidates(), CreateEndpointCandidates(), m_enableCrossingCandidates, m_enableEndpointCandidates, m_inputVertexListName, m_outputVertexListName, m_replaceCurrentVertexList, SelectClusters(), and TidyUp().

 {
     try
     {
         // INFO: See if there is already a vertex, and quit early if there is.
         //       The vertex has likely already been defined by another algorithm.
         const VertexList *pVertexList(nullptr);
         PandoraContentApi::GetCurrentList(*this, pVertexList);
         if (pVertexList != nullptr && !pVertexList->empty())
         {
             if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
                 std::cout << "CandidateVertexCreationAlgorithm: Vertex already defined, skipping" << std::endl;
 
             return STATUS_CODE_SUCCESS;
         }
 
         ClusterVector clusterVectorU, clusterVectorV, clusterVectorW;
         this->SelectClusters(clusterVectorU, clusterVectorV, clusterVectorW);
 
         std::string temporaryListName;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pVertexList, temporaryListName));
 
         if (m_enableEndpointCandidates)
         {
             this->CreateEndpointCandidates(clusterVectorU, clusterVectorV);
             this->CreateEndpointCandidates(clusterVectorU, clusterVectorW);
             this->CreateEndpointCandidates(clusterVectorV, clusterVectorW);
         }
 
         if (m_enableCrossingCandidates)
             this->CreateCrossingCandidates(clusterVectorU, clusterVectorV, clusterVectorW);
 
         if (!m_inputVertexListName.empty())
             this->AddInputVertices();
 
         if (!pVertexList->empty())
         {
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Vertex>(*this, m_outputVertexListName));
 
             if (m_replaceCurrentVertexList)
                 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Vertex>(*this, m_outputVertexListName));
         }
     }
     catch (StatusCodeException &statusCodeException)
     {
         this->TidyUp();
         throw statusCodeException;
     }
 
     this->TidyUp();
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::CandidateVertexCreationAlgorithm::SelectClusters	(	pandora::ClusterVector &	clusterVectorU,
		pandora::ClusterVector &	clusterVectorV,
		pandora::ClusterVector &	clusterVectorW
	)

private

Select a subset of input clusters (contained in the input list names) for processing in this algorithm.

Parameters

clusterVectorU	to receive the selected clusters in the u view
clusterVectorV	to receive the selected clusters in the v view
clusterVectorW	to receive the selected clusters in the w view

Definition at line 102 of file CandidateVertexCreationAlgorithm.cc.

References AddToSlidingFitCache(), f, lar_content::LArClusterHelper::GetClusterHitType(), lar_content::LArClusterHelper::GetLengthSquared(), m_inputClusterListNames, m_minClusterCaloHits, m_minClusterLengthSquared, m_nClustersPassingMaxCutsPar, m_reducedCandidates, m_selectionCutFactorMax, and lar_content::LArClusterHelper::SortByNHits().

Referenced by Run().

 {
     for (const std::string &clusterListName : m_inputClusterListNames)
     {
         const ClusterList *pClusterList(NULL);
         PANDORA_THROW_RESULT_IF_AND_IF(
             STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, clusterListName, pClusterList));
 
         if (!pClusterList || pClusterList->empty())
         {
             if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
                 std::cout << "CandidateVertexCreationAlgorithm: unable to find cluster list " << clusterListName << std::endl;
 
             continue;
         }
 
         const HitType hitType(LArClusterHelper::GetClusterHitType(*(pClusterList->begin())));
 
         if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
             throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
         ClusterVector &selectedClusterVector((TPC_VIEW_U == hitType) ? clusterVectorU
                 : (TPC_VIEW_V == hitType)                            ? clusterVectorV
                                                                      : clusterVectorW);
 
         if (!selectedClusterVector.empty())
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         ClusterVector sortedClusters(pClusterList->begin(), pClusterList->end());
         std::sort(sortedClusters.begin(), sortedClusters.end(), LArClusterHelper::SortByNHits);
 
         unsigned int nClustersPassingMaxCuts(0);
         if (m_reducedCandidates)
         {
             for (const Cluster *const pCluster : sortedClusters)
             {
                 float selectionCutFactor(1.f);
 
                 if (pCluster->GetParticleId() == E_MINUS)
                     selectionCutFactor = m_selectionCutFactorMax;
 
                 if (pCluster->GetNCaloHits() < m_minClusterCaloHits * selectionCutFactor)
                     continue;
 
                 if (LArClusterHelper::GetLengthSquared(pCluster) < m_minClusterLengthSquared * selectionCutFactor * selectionCutFactor)
                     continue;
 
                 nClustersPassingMaxCuts++;
             }
         }
 
         for (const Cluster *const pCluster : sortedClusters)
         {
             float selectionCutFactor(1.f);
 
             if (pCluster->GetParticleId() == E_MINUS && m_reducedCandidates)
             {
                 selectionCutFactor = (m_selectionCutFactorMax + 1.f) * 0.5f +
                     (m_selectionCutFactorMax - 1.f) * 0.5f * std::tanh(static_cast<float>(nClustersPassingMaxCuts) - m_nClustersPassingMaxCutsPar);
             }
 
             if (pCluster->GetNCaloHits() < m_minClusterCaloHits * selectionCutFactor)
                 continue;
 
             if (LArClusterHelper::GetLengthSquared(pCluster) < m_minClusterLengthSquared * selectionCutFactor * selectionCutFactor)
                 continue;
 
             try
             {
                 this->AddToSlidingFitCache(pCluster);
                 selectedClusterVector.push_back(pCluster);
             }
             catch (StatusCodeException &statusCodeException)
             {
                 if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                     throw statusCodeException;
             }
         }
     }
 }

void lar_content::CandidateVertexCreationAlgorithm::TidyUp ( )

private

Clear relevant algorithm member variables between events.

Definition at line 449 of file CandidateVertexCreationAlgorithm.cc.

References m_slidingFitResultMap.

Referenced by Run().

 {
     m_slidingFitResultMap.clear();
 }

Member Data Documentation

float lar_content::CandidateVertexCreationAlgorithm::m_chiSquaredCut

private

The chi squared cut (accept only 3D vertex positions with values below cut)

Definition at line 146 of file CandidateVertexCreationAlgorithm.h.

Referenced by CreateCrossingVertices(), CreateEndpointVertex(), and ReadSettings().

bool lar_content::CandidateVertexCreationAlgorithm::m_enableCrossingCandidates

private

Whether to create crossing vertex candidates.

Definition at line 151 of file CandidateVertexCreationAlgorithm.h.

Referenced by ReadSettings(), and Run().

bool lar_content::CandidateVertexCreationAlgorithm::m_enableEndpointCandidates

private

Whether to create endpoint-based candidates.

Definition at line 148 of file CandidateVertexCreationAlgorithm.h.

Referenced by ReadSettings(), and Run().

unsigned int lar_content::CandidateVertexCreationAlgorithm::m_extrapolationNSteps

private

Number of extrapolation steps, at each end of cluster, of specified size.

Definition at line 154 of file CandidateVertexCreationAlgorithm.h.

Referenced by GetSpacepoints(), and ReadSettings().

float lar_content::CandidateVertexCreationAlgorithm::m_extrapolationStepSize

private

The extrapolation step size in cm.

Definition at line 155 of file CandidateVertexCreationAlgorithm.h.

Referenced by GetSpacepoints(), and ReadSettings().

pandora::StringVector lar_content::CandidateVertexCreationAlgorithm::m_inputClusterListNames

private

The list of cluster list names.

Definition at line 136 of file CandidateVertexCreationAlgorithm.h.

Referenced by ReadSettings(), and SelectClusters().

std::string lar_content::CandidateVertexCreationAlgorithm::m_inputVertexListName

private

The list name for existing candidate vertices.

Definition at line 137 of file CandidateVertexCreationAlgorithm.h.

Referenced by AddInputVertices(), ReadSettings(), and Run().

float lar_content::CandidateVertexCreationAlgorithm::m_maxCrossingSeparationSquared

private

The separation (squared) between spacepoints below which a crossing can be identified.

Definition at line 156 of file CandidateVertexCreationAlgorithm.h.

Referenced by GetSpacepoints(), and ReadSettings().

float lar_content::CandidateVertexCreationAlgorithm::m_maxCrossingXDiscrepancy

private

The max cluster endpoint discrepancy.

Definition at line 153 of file CandidateVertexCreationAlgorithm.h.

Referenced by CreateCrossingVertices(), and ReadSettings().

float lar_content::CandidateVertexCreationAlgorithm::m_maxEndpointXDiscrepancy

private

The max cluster endpoint discrepancy.

Definition at line 149 of file CandidateVertexCreationAlgorithm.h.

Referenced by CreateEndpointVertex(), and ReadSettings().

unsigned int lar_content::CandidateVertexCreationAlgorithm::m_minClusterCaloHits

private

The min number of hits in base cluster selection method.

Definition at line 144 of file CandidateVertexCreationAlgorithm.h.

Referenced by ReadSettings(), and SelectClusters().

float lar_content::CandidateVertexCreationAlgorithm::m_minClusterLengthSquared

private

The min length (squared) in base cluster selection method.

Definition at line 145 of file CandidateVertexCreationAlgorithm.h.

Referenced by ReadSettings(), and SelectClusters().

float lar_content::CandidateVertexCreationAlgorithm::m_minNearbyCrossingDistanceSquared

private

The minimum allowed distance between identified crossing positions.

Definition at line 157 of file CandidateVertexCreationAlgorithm.h.

Referenced by GetSpacepoints(), and ReadSettings().

float lar_content::CandidateVertexCreationAlgorithm::m_nClustersPassingMaxCutsPar

private

Parameter for number of clusters passing the max base cluster selection cuts.

Definition at line 161 of file CandidateVertexCreationAlgorithm.h.

Referenced by ReadSettings(), and SelectClusters().

unsigned int lar_content::CandidateVertexCreationAlgorithm::m_nMaxCrossingCandidates

private

The max number of crossing candidates to create.

Definition at line 152 of file CandidateVertexCreationAlgorithm.h.

Referenced by CreateCrossingVertices(), and ReadSettings().

std::string lar_content::CandidateVertexCreationAlgorithm::m_outputVertexListName

private

The name under which to save the output vertex list.

Definition at line 138 of file CandidateVertexCreationAlgorithm.h.

Referenced by ReadSettings(), and Run().

bool lar_content::CandidateVertexCreationAlgorithm::m_reducedCandidates

private

Whether to reduce the number of candidates.

Definition at line 159 of file CandidateVertexCreationAlgorithm.h.

Referenced by ReadSettings(), and SelectClusters().

bool lar_content::CandidateVertexCreationAlgorithm::m_replaceCurrentVertexList

private

Whether to replace the current vertex list with the output list.

Definition at line 139 of file CandidateVertexCreationAlgorithm.h.

Referenced by ReadSettings(), and Run().

float lar_content::CandidateVertexCreationAlgorithm::m_selectionCutFactorMax

private

Maximum factor to multiply the base cluster selection cuts.

Definition at line 160 of file CandidateVertexCreationAlgorithm.h.

Referenced by ReadSettings(), and SelectClusters().

TwoDSlidingFitResultMap lar_content::CandidateVertexCreationAlgorithm::m_slidingFitResultMap

private

The sliding fit result map.

Definition at line 142 of file CandidateVertexCreationAlgorithm.h.

Referenced by AddToSlidingFitCache(), GetCachedSlidingFitResult(), and TidyUp().

unsigned int lar_content::CandidateVertexCreationAlgorithm::m_slidingFitWindow

private

The layer window for the sliding linear fits.

Definition at line 141 of file CandidateVertexCreationAlgorithm.h.

Referenced by AddToSlidingFitCache(), and ReadSettings().

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

larpandoracontent/v04_14_00/source/larpandoracontent/LArVertex/CandidateVertexCreationAlgorithm.h
larpandoracontent/v04_14_00/source/larpandoracontent/LArVertex/CandidateVertexCreationAlgorithm.cc

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation