#include <LayerSplittingAlgorithm.h>

Inheritance diagram for lar_content::LayerSplittingAlgorithm:

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

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

pandora::StatusCode	DivideCaloHits (const pandora::Cluster *const pCluster, pandora::CaloHitList &firstCaloHitList, pandora::CaloHitList &secondCaloHitList) const
	Divide calo hits in a cluster into two lists, each associated with a separate fragment cluster. More...

pandora::StatusCode	FindBestSplitLayer (const pandora::Cluster *const pCluster, unsigned int &splitLayer) const
	Find the best layer for splitting the cluster. More...

pandora::StatusCode	DivideCaloHits (const pandora::Cluster *const pCluster, const unsigned int &splitLayer, pandora::CaloHitList &firstCaloHitList, pandora::CaloHitList &secondCaloHitList) const
	Split the cluster into two fragments at the input layer. More...

float	CalculateRms (const pandora::Cluster *const pCluster, const unsigned int &firstLayer, const unsigned int &secondLayer) const
	Calculate rms deviation of cluster centroids between two extremal layers. More...

Private Attributes
unsigned int	m_minClusterLayers

unsigned int	m_layerWindow

float	m_maxScatterRms

float	m_maxScatterCosTheta

float	m_maxSlidingCosTheta

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

pandora::StatusCode	RunUsingCurrentList () const
	Run the algorithm using the current cluster list as input. More...

Detailed Description

LayerSplittingAlgorithm class.

Definition at line 19 of file LayerSplittingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::LayerSplittingAlgorithm::LayerSplittingAlgorithm ( )

Default constructor.

Definition at line 18 of file LayerSplittingAlgorithm.cc.

                                                  :
     m_minClusterLayers(20),
     m_layerWindow(10),
     m_maxScatterRms(0.35f),
     m_maxScatterCosTheta(0.5f),
     m_maxSlidingCosTheta(0.866f)
 {
 }

Member Function Documentation

float lar_content::LayerSplittingAlgorithm::CalculateRms	(	const pandora::Cluster *const	pCluster,
		const unsigned int &	firstLayer,
		const unsigned int &	secondLayer
	)		const

private

Calculate rms deviation of cluster centroids between two extremal layers.

Parameters

pCluster	the input cluster
firstLayer	the first extremal layer
secondLayer	the second extremal layer

Definition at line 117 of file LayerSplittingAlgorithm.cc.

 {
     const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());
 
     const unsigned int innerLayer(std::min(firstLayer, secondLayer));
     const unsigned int outerLayer(std::max(firstLayer, secondLayer));
 
     const CartesianVector innerPosition(pCluster->GetCentroid(innerLayer));
     const CartesianVector outerPosition(pCluster->GetCentroid(outerLayer));
     const CartesianVector predictedDirection((outerPosition - innerPosition).GetUnitVector());
 
     float totalChi2(0.f);
     float totalLayers(0.f);
 
     for (unsigned int iLayer = innerLayer + 1; iLayer + 1 < outerLayer; ++iLayer)
     {
         if (orderedCaloHitList.find(iLayer) == orderedCaloHitList.end())
             continue;
 
         const CartesianVector hitPosition(pCluster->GetCentroid(iLayer));
         const CartesianVector predictedPosition(innerPosition + predictedDirection * predictedDirection.GetDotProduct(hitPosition - innerPosition));
 
         totalChi2 += (predictedPosition - hitPosition).GetMagnitudeSquared();
         totalLayers += 1.f;
     }
 
     if (totalLayers > 0.f)
         return std::sqrt(totalChi2 / totalLayers);
 
     return 0.f;
 }

pandora::StatusCode lar_content::LayerSplittingAlgorithm::DivideCaloHits	(	const pandora::Cluster *const	pCluster,
		pandora::CaloHitList &	firstCaloHitList,
		pandora::CaloHitList &	secondCaloHitList
	)		const

privatevirtual

Divide calo hits in a cluster into two lists, each associated with a separate fragment cluster.

Parameters

pCluster	address of the cluster
firstCaloHitList	the hits in the first fragment
secondCaloHitList	the hits in the second fragment

Implements lar_content::ClusterSplittingAlgorithm.

pandora::StatusCode lar_content::LayerSplittingAlgorithm::DivideCaloHits	(	const pandora::Cluster *const	pCluster,
		const unsigned int &	splitLayer,
		pandora::CaloHitList &	firstCaloHitList,
		pandora::CaloHitList &	secondCaloHitList
	)		const

private

Split the cluster into two fragments at the input layer.

Parameters

pCluster	the input cluster
splitLayer	the split layer
firstCaloHitList	the hits in the first cluster fragment
secondCaloHitList	the hits in the second cluster fragment

StatusCode lar_content::LayerSplittingAlgorithm::FindBestSplitLayer	(	const pandora::Cluster *const	pCluster,
		unsigned int &	splitLayer
	)		const

private

Find the best layer for splitting the cluster.

Parameters

pCluster	the input cluster
splitLayer	the best layer

Definition at line 41 of file LayerSplittingAlgorithm.cc.

 {
     const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());
 
     if (orderedCaloHitList.size() < m_minClusterLayers)
         return STATUS_CODE_NOT_FOUND;
 
     bool foundSplit(false);
 
     float bestCosTheta(1.f);
     CartesianVector bestPosition(0.f, 0.f, 0.f);
 
     for (unsigned int iLayer = pCluster->GetInnerPseudoLayer() + 4; iLayer + 4 <= pCluster->GetOuterPseudoLayer(); ++iLayer)
     {
         if (orderedCaloHitList.find(iLayer) == orderedCaloHitList.end())
             continue;
 
         unsigned int innerLayer((pCluster->GetInnerPseudoLayer() + m_layerWindow > iLayer) ? pCluster->GetInnerPseudoLayer() : iLayer - m_layerWindow);
         unsigned int outerLayer((iLayer + m_layerWindow > pCluster->GetOuterPseudoLayer()) ? pCluster->GetOuterPseudoLayer() : iLayer + m_layerWindow);
 
         for (; innerLayer >= pCluster->GetInnerPseudoLayer(); --innerLayer)
         {
             if (orderedCaloHitList.find(innerLayer) != orderedCaloHitList.end())
                 break;
         }
 
         for (; outerLayer <= pCluster->GetOuterPseudoLayer(); ++outerLayer)
         {
             if (orderedCaloHitList.find(outerLayer) != orderedCaloHitList.end())
                 break;
         }
 
         const CartesianVector splitPosition(pCluster->GetCentroid(iLayer));
         const CartesianVector innerPosition(pCluster->GetCentroid(innerLayer));
         const CartesianVector outerPosition(pCluster->GetCentroid(outerLayer));
 
         const CartesianVector r1(innerPosition - splitPosition);
         const CartesianVector r2(outerPosition - splitPosition);
         const CartesianVector p1(r1.GetUnitVector());
         const CartesianVector p2(r2.GetUnitVector());
 
         const float cosTheta(-p1.GetDotProduct(p2));
         const float rms1(this->CalculateRms(pCluster, innerLayer, iLayer));
         const float rms2(this->CalculateRms(pCluster, outerLayer, iLayer));
         const float rms(std::max(rms1, rms2));
 
         float rmsCut(std::numeric_limits<float>::max());
 
         if (cosTheta > 0.f)
         {
             rmsCut = m_maxScatterRms;
 
             if (cosTheta > m_maxScatterCosTheta)
             {
                 rmsCut *= ((m_maxSlidingCosTheta > cosTheta) ? (m_maxSlidingCosTheta - cosTheta) / (m_maxSlidingCosTheta - m_maxScatterCosTheta) : 0.f);
             }
         }
 
         if (rms < rmsCut && cosTheta < bestCosTheta)
         {
             bestCosTheta = cosTheta;
             bestPosition = splitPosition;
 
             splitLayer = iLayer;
             foundSplit = true;
         }
     }
 
     if (!foundSplit)
         return STATUS_CODE_NOT_FOUND;
 
     return STATUS_CODE_SUCCESS;
 }

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

privatevirtual

Reimplemented from lar_content::ClusterSplittingAlgorithm.

Definition at line 183 of file LayerSplittingAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterLayers", m_minClusterLayers));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "LayerWindow", m_layerWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxScatterRms", m_maxScatterRms));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxScatterCosTheta", m_maxScatterCosTheta));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxSlidingCosTheta", m_maxSlidingCosTheta));
 
     return ClusterSplittingAlgorithm::ReadSettings(xmlHandle);
 }

Member Data Documentation

unsigned int lar_content::LayerSplittingAlgorithm::m_layerWindow

private

Definition at line 61 of file LayerSplittingAlgorithm.h.

float lar_content::LayerSplittingAlgorithm::m_maxScatterCosTheta

private

Definition at line 63 of file LayerSplittingAlgorithm.h.

float lar_content::LayerSplittingAlgorithm::m_maxScatterRms

private

Definition at line 62 of file LayerSplittingAlgorithm.h.

float lar_content::LayerSplittingAlgorithm::m_maxSlidingCosTheta

private

Definition at line 64 of file LayerSplittingAlgorithm.h.

unsigned int lar_content::LayerSplittingAlgorithm::m_minClusterLayers

private

Definition at line 60 of file LayerSplittingAlgorithm.h.

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

larpandoracontent/larpandoracontent/LArTwoDReco/LArClusterSplitting/LayerSplittingAlgorithm.h
larpandoracontent/larpandoracontent/LArTwoDReco/LArClusterSplitting/LayerSplittingAlgorithm.cc

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation