CutClusterCharacterisationAlgorithm class. More...

#include <CutClusterCharacterisationAlgorithm.h>

Inheritance diagram for lar_content::CutClusterCharacterisationAlgorithm:

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

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

	~ClusterCharacterisationBaseAlgorithm ()
	Destructor. More...

Static Public Member Functions
static float	GetVertexDistance (const pandora::Algorithm const pAlgorithm, const pandora::Cluster const pCluster)
	Get the distance between the interaction vertex (if present in the current vertex list) and a provided cluster. More...

static float	GetShowerFitWidth (const pandora::Algorithm const pAlgorithm, const pandora::Cluster const pCluster, const unsigned int showerFitWindow)
	Get a measure of the width of a cluster, using a sliding shower fit result. More...

Private Member Functions
virtual bool	IsClearTrack (const pandora::Cluster *const pCluster) const
	Whether cluster is identified as a clear track. More...

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

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

unsigned int	m_slidingShowerFitWindow
	The layer window for the sliding shower fits. More...

unsigned int	m_minCaloHitsCut
	The minimum number of calo hits to qualify as a track. More...

float	m_maxShowerLengthCut
	The maximum cluster length to qualify as a shower. More...

float	m_pathLengthRatioCut
	The maximum ratio of path length to straight line length to qualify as a track. More...

float	m_rTWidthRatioCut
	The maximum ratio of transverse fit position width to straight line length to qualify as a track. More...

float	m_vertexDistanceRatioCut
	The maximum ratio of vertex separation to straight line length to qualify as a track. More...

float	m_showerWidthRatioCut
	The maximum ratio of shower fit width to straight line length to qualify as a track. More...

Additional Inherited Members
Protected Member Functions inherited from lar_content::ClusterCharacterisationBaseAlgorithm
pandora::StatusCode	Run ()

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

Protected Attributes inherited from lar_content::ClusterCharacterisationBaseAlgorithm
pandora::StringVector	m_inputClusterListNames
	The names of the input cluster lists. More...

bool	m_zeroMode
	Whether to zero all existing cluster particle id, overrides all other parameters. More...

bool	m_overwriteExistingId
	Whether to consider any clusters that already have an assigned particle id. More...

bool	m_useUnavailableClusters
	Whether to consider clusters that are already constituents of a pfo. More...

Detailed Description

CutClusterCharacterisationAlgorithm class.

Definition at line 19 of file CutClusterCharacterisationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::CutClusterCharacterisationAlgorithm::CutClusterCharacterisationAlgorithm ( )

Default constructor.

Definition at line 24 of file CutClusterCharacterisationAlgorithm.cc.

                                                                          :
     m_slidingFitWindow(5),
     m_slidingShowerFitWindow(10),
     m_minCaloHitsCut(6),
     m_maxShowerLengthCut(80.f),
     m_pathLengthRatioCut(1.005f),
     m_rTWidthRatioCut(0.05f),
     m_vertexDistanceRatioCut(0.5f),
     m_showerWidthRatioCut(0.35f)
 {
 }

Member Function Documentation

float lar_content::CutClusterCharacterisationAlgorithm::GetShowerFitWidth	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::Cluster *const	pCluster,
		const unsigned int	showerFitWindow
	)

static

Get a measure of the width of a cluster, using a sliding shower fit result.

Parameters

pAlgorithm	the address of the calling algorithm
pCluster	address of the cluster
showerFitWindow	the layer window used for the sliding shower fit

Returns: the shower fit width

Definition at line 55 of file CutClusterCharacterisationAlgorithm.cc.

 {
     try
     {
         const TwoDSlidingShowerFitResult showerFitResult(pCluster, showerFitWindow, LArGeometryHelper::GetWireZPitch(pAlgorithm->GetPandora()));
         const LayerFitResultMap &layerFitResultMapS(showerFitResult.GetShowerFitResult().GetLayerFitResultMap());
         const LayerFitResultMap &layerFitResultMapP(showerFitResult.GetPositiveEdgeFitResult().GetLayerFitResultMap());
         const LayerFitResultMap &layerFitResultMapN(showerFitResult.GetNegativeEdgeFitResult().GetLayerFitResultMap());
 
         if (!layerFitResultMapS.empty())
         {
             float showerFitWidth(0.f);
 
             for (const auto &mapEntryS : layerFitResultMapS)
             {
                 LayerFitResultMap::const_iterator iterP = layerFitResultMapP.find(mapEntryS.first);
                 LayerFitResultMap::const_iterator iterN = layerFitResultMapN.find(mapEntryS.first);
 
                 if ((layerFitResultMapP.end() != iterP) && (layerFitResultMapN.end() != iterN))
                     showerFitWidth += std::fabs(iterP->second.GetFitT() - iterN->second.GetFitT());
             }
 
             return showerFitWidth;
         }
     }
     catch (const StatusCodeException &)
     {
     }
 
     return -1.f;
 }

float lar_content::CutClusterCharacterisationAlgorithm::GetVertexDistance	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::Cluster *const	pCluster
	)

static

Get the distance between the interaction vertex (if present in the current vertex list) and a provided cluster.

Parameters

pAlgorithm	the address of the calling algorithm
pCluster	address of the cluster

Returns: the vertex distance

Definition at line 38 of file CutClusterCharacterisationAlgorithm.cc.

 {
     const VertexList *pVertexList = nullptr;
     (void)PandoraContentApi::GetCurrentList(*pAlgorithm, pVertexList);
 
     if (!pVertexList || (pVertexList->size() != 1) || (VERTEX_3D != pVertexList->front()->GetVertexType()))
         return -1.f;
 
     const Vertex *const pVertex(pVertexList->front());
     const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
 
     const CartesianVector vertexPosition2D(LArGeometryHelper::ProjectPosition(pAlgorithm->GetPandora(), pVertex->GetPosition(), hitType));
     return LArClusterHelper::GetClosestDistance(vertexPosition2D, pCluster);
 }

bool lar_content::CutClusterCharacterisationAlgorithm::IsClearTrack ( const pandora::Cluster *const pCluster ) const

privatevirtual

Whether cluster is identified as a clear track.

Parameters

pCluster address of the relevant cluster

Returns: boolean

Implements lar_content::ClusterCharacterisationBaseAlgorithm.

Definition at line 89 of file CutClusterCharacterisationAlgorithm.cc.

 {
     if (pCluster->GetNCaloHits() < m_minCaloHitsCut)
         return false;
 
     float straightLineLength(-1.f), integratedPathLength(-1.f);
     float rTMin(+std::numeric_limits<float>::max()), rTMax(-std::numeric_limits<float>::max());
 
     try
     {
         const TwoDSlidingFitResult slidingFitResult(pCluster, m_slidingFitWindow, LArGeometryHelper::GetWireZPitch(this->GetPandora()));
         const CartesianVector globalMinLayerPosition(slidingFitResult.GetGlobalMinLayerPosition());
         straightLineLength = (slidingFitResult.GetGlobalMaxLayerPosition() - globalMinLayerPosition).GetMagnitude();
 
         integratedPathLength = 0.f;
         CartesianVector previousFitPosition(globalMinLayerPosition);
 
         for (const auto &mapEntry : slidingFitResult.GetLayerFitResultMap())
         {
             rTMin = std::min(rTMin, static_cast<float>(mapEntry.second.GetFitT()));
             rTMax = std::max(rTMax, static_cast<float>(mapEntry.second.GetFitT()));
 
             CartesianVector thisFitPosition(0.f, 0.f, 0.f);
             slidingFitResult.GetGlobalPosition(mapEntry.second.GetL(), mapEntry.second.GetFitT(), thisFitPosition);
             integratedPathLength += (thisFitPosition - previousFitPosition).GetMagnitude();
             previousFitPosition = thisFitPosition;
         }
     }
     catch (const StatusCodeException &)
     {
     }
 
     if (straightLineLength < std::numeric_limits<float>::epsilon())
         return false;
 
     if (straightLineLength > m_maxShowerLengthCut)
         return true;
 
     if ((integratedPathLength < std::numeric_limits<float>::epsilon()) || (integratedPathLength / straightLineLength > m_pathLengthRatioCut))
         return false;
 
     if ((rTMax - rTMin) / straightLineLength > m_rTWidthRatioCut)
         return false;
 
     const float vertexDistance(CutClusterCharacterisationAlgorithm::GetVertexDistance(this, pCluster));
 
     if ((vertexDistance > std::numeric_limits<float>::epsilon()) && ((vertexDistance / straightLineLength) > m_vertexDistanceRatioCut))
         return false;
 
     const float showerFitWidth(CutClusterCharacterisationAlgorithm::GetShowerFitWidth(this, pCluster, m_slidingShowerFitWindow));
 
     if ((showerFitWidth < std::numeric_limits<float>::epsilon()) || ((showerFitWidth / straightLineLength) > m_showerWidthRatioCut))
         return false;
 
     return true;
 }

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

private

Definition at line 148 of file CutClusterCharacterisationAlgorithm.cc.

 {
     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, "SlidingShowerFitWindow", m_slidingShowerFitWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCaloHitsCut", m_minCaloHitsCut));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxShowerLengthCut", m_maxShowerLengthCut));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PathLengthRatioCut", m_pathLengthRatioCut));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "RTWidthRatioCut", m_rTWidthRatioCut));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VertexDistanceRatioCut", m_vertexDistanceRatioCut));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ShowerWidthRatioCut", m_showerWidthRatioCut));
 
     return ClusterCharacterisationBaseAlgorithm::ReadSettings(xmlHandle);
 }